vectronic

First Real Project on the Pocket NC

hello.vectronic@gmail.com (vectronic) — Tue, 21 Oct 2025 00:00:00 +0000

The first “real world” project on the Pocket NC was to create 2 replacement Oilite bushes for the mains powered Synchron motor in a 1940’s Kit Cat Clock.

I’m much more familiar with Fusion 360 and was able to generate a program with 9 operations using 4 tools:

I used the Vers Wireless Touch Probe to setup the work coordinates, but just did the touch off manually. I also used it connected to the receiver instead of wirelessly as the receiver is yet to be integrated into the Pocket NC tool length sensor. So the next step is definitely to integrate with the hardware and automate within GCode.

Anyway, less words, more pictures!

Here is a video showing an overview of the setup:

iPad for local control
computer for more detailed configuration, Fusion work and management of the machine view videos

Here is a video showing a close up of the final parting off step:

Closeups of the results (new on the left, original on the right):

And for those so inclined, here is a full length video of the operation from within the enclosure:

If you got past the glitchy, out of focus moments, awkward manual tool changes and endless B axis unwind, you might have enjoyed the ability to simply snap off the workpiece as it was left with a minimal 0.1mm ring around the central hole connecting it to the stock.

As observed before, I think I need to upgrade the camera technology here to improve depth of field, vibration handling and enclosure open/close remote control.

I also really need to understand how to use the M999 GCode to avoid that painfully long B-Axis unwind at the end: https://pentamachine.atlassian.net/wiki/spaces/KCUR/pages/1713471506/Rotary+Unwind

Bun, WASM and Rust projects with GitHub Actions

hello.vectronic@gmail.com (vectronic) — Tue, 29 Jul 2025 00:00:00 +0000

Following on from a previously outlined move to Deno I’ve now moved to Bun 😅

The main thing I moved to Deno for was a nice way to acheive:

A single executable binary via Deno Compile.
Cross platform executables via cross-compilation support in Deno.
Ability to dynamically load and run additional logic after installation via Deno’s support for the Javascript import() function.

After a while I discovered these items don’t all work well together. It came to light that dynamic loading of modules external to the compiled Deno application was not really supported: https://github.com/denoland/deno/issues/18327 Fair enough, everyone has their priorities…

I then read (but can’t remember where) that Bun does support this. 🥳 Ok, game on!

But (there is always a but…) in Bun there is no support for loading from a remote URL: https://github.com/oven-sh/bun/issues/38 Again, everyone has their priorities… 😣

So in Bun, dynamic imports can reference a local filesystem URL only. However, they CAN be loaded from a compiled executable and they can be loaded from absolute paths or paths relative to the compiled executable. To workaround lack of remote URL support, I wrote a little helper to pull remote modules locally:

https://github.com/flowscripter/dynamic-plugin-framework/blob/main/src/plugin_manager/util/PluginLoader.ts#L26-L47

after which I can import OK here:

https://github.com/flowscripter/dynamic-plugin-framework/blob/main/src/plugin_manager/util/PluginLoader.ts#L85

So we’re good and I am still mostly sane!

So, after previously presenting: “a set of template Deno, Rust and WASM projects on GitHub” in this post I am now presenting:

“a set of template Bun, Rust and WASM projects on GitHub” together with GitHub Actions, Shared Workflows and Template Workflows for continuous integration.

For my use cases I am looking to achieve:

A scriptable high-level layer (Bun TypeScript) controlling a performant lower-level core (Rust).
A single executable binary which can be cross-compiled.
Ability for the executable to dynamically load and run additional logic after installation via the Javascript import() function.
Support for running as much as possible agnostically as an OS process or in a browser runtime with the ability to compile Rust to WASM.
Simple project scaffolding via Bun’s all-in-one approach

Just on that last point… turns out Bun doesn’t do linting or documentation generation https://github.com/oven-sh/bun/issues/2246 There we are with priorities again… 😣 So for this I am actually still using Deno 🤪 as it “just works” (and seems to handle running on a Bun biased codebase):

deno fmt
deno lint index.ts
deno doc --html index.ts

Features

Before getting into details, some of the feature highlights I’ve managed to achieve are:

A single executable available for Linux, MacOS (available via brew) and Windows (available via winget) with Rust FFI and dynamic import.
Roughly the same functionality running in a browser with WASM (dynamic import not applicable here).
Instrumented test coverage analysis
Working example projects with GitHub actions for testing, compiling, versioning and releasing for:
- Rust
- Bun
- Rust + Bun via FFI Bindings
- Rust + Bun via WASM
Automated PRs, testing, merging, versioning and releasing for internal and 3rd party dependencies
Automatically updated API documentation

Repositories

The GitHub repositories involved in this effort are as follows:

“Application” Projects

flowscripter/template-bun-executable: Project template for a Bun executable.
flowscripter/template-bun-webapp: Project template for a Bun based webapp with Bun and Rust based WASM library dependencies.

“Simple Library” Projects

flowscripter/template-bun-library: Project template for a Bun library.
flowscripter/template-rust-library: Project template for a Rust library.

“Glue Library” Projects

flowscripter/template-bun-rust-library: Project template for a Rust library with Bun FFI bindings.
flowscripter/template-bun-wasm-rust-library: Project template for a Rust library compiled to WASM exposed as a Bun module.

“CI” Projects

flowscripter/.github: GitHub Actions, Shared Workflows and Workflow Templates

A picture is worth a 1000 words… or maybe its just confusing…

It’s big and complex, but I hope the following describes things visually. It shows the projects (together with their artifacts and inter-dependencies).

Click on it to open in a larger form.

Flowscripter CI - click to enlarge

Feedback

If anyone is interested in this and has actually read this far, I would love some feedback on:

suggested improvements or recommendations
any issues discovered

Minitel Terminal Connected via Asterisk

hello.vectronic@gmail.com (vectronic) — Mon, 30 Dec 2024 00:00:00 +0000

I took some time during the holiday to get the Minitel I inherited from the parents-in-law connected to my home server. As I already run Asterisk on the server and have analogue telephony hardware, I wanted to use the analogue dialup modem rather than opting for the serial port available on some Minitel terminals.

Overall the setup is:

Analogue Phone + Minitel Terminal => Grandstream ATA => Asterisk => SoftModem => Python Minitel Server

Here is a video showing initial connection and navigating to some adult content of the era:

Apart from soldering some raw wires onto the French phone plug, the Minitel terminal remains unmodified:

Most of the work to get this up and running was covered in this excellent blog entry: Building a Standalone Softmodem Enabled PABX 🙏

Things went quite smoothly until I got stuck with garbled text on the screen when connecting to the Minitel server. After checking the analogue side of things (and also successfully connecting to the Telstar service hosted at https://glasstty.com) I started to suspect byte processing logic in the Python Minitel server…

Indeed, the issue turned out to be that the Minitel server had been developed to work with the original version of the Softmodem code which does not perform parity processing. Hence the Minitel server was performing this. As I was using a more up to date fork of the Softmodem, it was already performing the parity processing: https://github.com/johnnewcombe/asterisk-Softmodem.

I created a fork of the Minitel server allowing parity processing to be disabled: https://github.com/vectronic/minitel-server With this patch in place I was able to get it all working on FreeBSD with Asterisk 18. 🥳

Now I need to find an idea of what to connect this thing to rather than just local test and demo services….🤔

Further Details and Notes

UPDATE: April 4th 2026

There is now a Docker image of this available: vectronic/asterisk-minitel

See source and instructions at: https://github.com/vectronic/asterisk-minitel-docker

This is build on Linux instead of Ubuntu thus avoiding patches below and the PR for minitel-server has been merged upstream so all in all things are a lot simpler.

Asterisk 18 and Softmodem Installation

In a FreeBSD jail:

pkg update && pkg upgrade
pkg install git
git clone --depth 1 https://git.FreeBSD.org/ports.git /usr/ports

Edit /usr/ports/Templates/config.site and change ${ac_cv_header_byteswap_h=yes} to no

setenv ALLOW_UNSUPPORTED_SYSTEM 1
cd /usr/ports/net/asterisk18
make
curl https://raw.githubusercontent.com/johnnewcombe/asterisk-Softmodem/app_softmodem/app_softmodem.c > /usr/ports/net/asterisk18/work/asterisk-18.25.0/apps/app_softmodem.c

Edit /usr/ports/net/asterisk18/work/asterisk-18.25.0/apps/app_softmodem.c and add at the top:

#define TRUE 1
#define FALSE 1

cd /usr/ports/net/asterisk18/work/asterisk-18.25.0
make menuselect
make 
cd /usr/ports/net/asterisk18/
make deinstall 
make

pw groupmod -n asterisk -g 1001
pw group mod asterisk -m asterisk
chown -R asterisk:asterisk /usr/local/etc/asterisk/ /usr/local/lib/asterisk /usr/local/share/asterisk
chmod 644 /usr/local/etc/asterisk/*

Asterisk Configuration Files

root@asterisk:~ # cat /usr/local/etc/asterisk/pjsip.conf
[transport-udp]
type=transport
protocol=udp
bind=192.168.22.22

[6000]
type=endpoint
context=foo
disallow=all
allow=ulaw
transport=transport-udp
auth=commonauth
aors=6000

[commonauth]
type=auth
auth_type=userpass
username=xxx
password=xxx

[6000]
type=aor
max_contacts=1

root@asterisk:~ # cat /usr/local/etc/asterisk/extensions.conf
[foo]

exten = 1,1,Dial(PJSIP/6000,20)

exten => 3610,1,Answer()
exten => 3610,n,Softmodem(127.0.0.1,3610,v(V23)ld(7)s(1)e)
exten => 3610,n,Hangup()

exten => 3611,1,Answer()
exten => 3611,n,Softmodem(127.0.0.1,3611,v(V23)ld(7)s(1)e)
exten => 3611,n,Hangup()

exten => 3614,1,Answer()
exten => 3614,n,Softmodem(127.0.0.1,3614,v(V23)ld(7)s(1)e)
exten => 3614,n,Hangup()

exten => 3615,1,Answer()
exten => 3615,n,Softmodem(127.0.0.1,3615,v(V23)ld(7)s(1)e)
exten => 3615,n,Hangup()

Minitel Server Setup

git clone --depth 1 https://github.com/vectronic/minitel-server.git

Edit minitel-server/constant.py and change PROCESS_PARITY from True to False

Setup the server to run on boot (I know, I know, this needs to be changed to a non-root user):

root@asterisk:~ # cat /usr/local/etc/rc.d/minitel
#!/bin/sh

# PROVIDE: minitel
# REQUIRE: LOGIN
# KEYWORD: shutdown

. /etc/rc.subr

name=minitel
rcvar=minitel_enable

load_rc_config $name

: ${minitel_enable="NO"}
: ${minitel_home_dir:="/root/minitel-server"}

pidfile="/var/run/${name}.pid"
command=/usr/sbin/daemon
command_args="-f -P ${pidfile} -u root /bin/sh -c 'cd /root/minitel-server && /usr/local/bin/python3.11 MinitelSrv.py'"

run_rc_command "$1"

Start Services

sysrc asterisk_enable="YES"
sysrc minitel_enable="YES"

service asterisk start
service minitel start

Beginner Chips

hello.vectronic@gmail.com (vectronic) — Thu, 21 Nov 2024 00:00:00 +0000

A second attempt at the tutorial from Penta was reasonably successful.

The first attempt was most definitely not: the collet I used didn’t tighten up on the workpiece enough and the workpiece moved towards the mill during the operation. As I looked on in awe at the increasing size of the chips without thinking to intervene, the mill eventually plunged into the workpiece which then moved and snapped the mill. I have video but won’t publish that… As I said: not successful, beginner chips 🥹

This second attempt was reasonably successful excepting a G-code error near the end of the run. I believe it was because the tool length did not provide enough clearance for parting off, although I am sure I ran the simulation first… Hence a third attempt is in order to double check that everything works as expected and I am doing what is expected of me!

Here is a video showing some of the key action:

At some point I will need to upgrade from the old iPhone in use for filming as I’m not happy with the quality of the video.

Next steps:

third attempt at the tutorial
probably a second run at the sample cube piece tutorial now that I am setup in the enclosure with video recording
integration of the Vers Wireless Touch Probe which seems to have had some further activity.

Pocket NC Enclosure Reality

hello.vectronic@gmail.com (vectronic) — Sat, 14 Sep 2024 00:00:00 +0000

Over a long duration I finally constructed the Pocket NC enclosure. And now after an even longer period of time I am posting about it.

Features include:

(reasonably) soft close/open with gas struts
high visibility with clear perspex on four sides
elevated mounting of Pocket NC to allow longer stock in the ER40 collet
enclosure open signal integration with Pocket NC
internal iPhone mount for video recording of CNC sessions 🤓
integrated LED lighting
lighting partially switches off when opening to avoid blinding the user 😎

The build pretty much worked out as planned. There was only one main “gotcha” which was that the gas struts exert a significant amount of force on the frame resulting in a large degree of shaking when opening the enclosure. For this reason I needed to add some unplanned bracing plates on the rear side uprights.

The rear of the enclosure provides space for mounting:

a power board
LED lighting power supply
a network switch
a POE lightning cable to power and connect an internally mounted iPhone for recording CNC sessions
a POE lightning cable to power and connect an externally located iPad for the Penta interface
the receiver for a Vers Wireless Touch Probe - integration of this is the next step on the journey…

I also worked on a small fitting to allow a dial gauge to be attached. I was planning to measure repeatability, but I’m not sure how useful this will be in practice given it is mounted on a movable part of the machine…

It all looks pretty cool with the iPad beside it for convenient control:

Here is a video showing some of the details:

Pocket NC Enclosure Design

hello.vectronic@gmail.com (vectronic) — Tue, 03 Oct 2023 00:00:00 +0000

Before getting serious with the Pocket NC V2-50CHK, I want to build an enclosure for it. Although there is one available to buy commercially, I wanted to build a custom one myself that has:

more vertical clearance underneath the B axis so that I can use longer stock in the ER-40 collet
excellent access to the machine when open
excellent visibility of the machine when closed
built-in LED lighting

I plan to make the enclosure using 80-20 style aluminium profile and fittings from KJN.

Gas-struts will keep the lid up when in the open position:

Basic dimensions and a more detailed view at each of the sections:

Here is a link to the Fusion 360 design: [enclosure](https://a360.co/3LIx0KI

First Pocket NC chips!

hello.vectronic@gmail.com (vectronic) — Wed, 05 Jul 2023 00:00:00 +0000

The first chips have been produced on my new pride and joy, the Penta Machine’s Pocket NC V2-50CHK!

Here is short video showing the chips flying when following the excellent First Part Tutorial.

There should have been a video here but your browser does not seem to support it.

After many years being consumed by software I am now back straddling software and hardware ❤️

Nostalgia - NetToaster

hello.vectronic@gmail.com (vectronic) — Tue, 03 Jan 2023 00:00:00 +0000

I’ve held onto the hard copy of my Electrical Engineering Thesis for around 25 years. It recently suffered water damage so I decided it was time to immortalise it on the world wide web.

I say ‘world wide web’ in preference to modern terminology such as ’net’, ‘web’ etc. in homage to the title of the thesis:

A TOASTER WITH A WORLD WIDE WEB INTERFACE.

Here is a photo of the ‘completed’ project:

and a photo of the electronics board:

I say ‘completed’ as I suffered a major setback about 6 weeks before the due date when I fried the ethernet controller chip. The lead time was over 3 months and so I set myself on a new journey of implementing network connectivity over SLIP.

This ate into my development time and consequently I only managed to get to the point where I had a multi-tasking OS running two processes: one outputting ‘S’ and one outputting ‘O’ over serial. Get it…? SOS…

Still, designing and building a compute board to interface with the Hitachi SH1 processor and porting XINU to run on it was not easy - and I’m still proud of my achievement to this day.

Click on the cover for the full thesis:

And click on the floppy for the code:

Nostalgia - Pogo Web Browser

hello.vectronic@gmail.com (vectronic) — Tue, 03 Jan 2023 00:00:00 +0000

More than 20 years ago, in the ‘dotcom’ era, I worked for the web design agency Razorfish and managed to get involved in a more exciting gig working for a hardware spin-off developing the Pogo Mobile.

I was responsible for the development of the embedded web browser that acted as the sole UI for the device.

I came across this printout of a screenshot I took when the browser rendering started to take shape.

Fusion 360 Baby Steps

hello.vectronic@gmail.com (vectronic) — Mon, 26 Sep 2022 00:00:00 +0000

Life is all about incremental steps forward. And… some steps backwards and sideways as well…

I switched from FreeCAD to Fusion 360 as I want to end up doing some 5 Axis CNC Machining. Currently FreeCAD support for this is very… far… away…

So here are the results of applying the same learning process of modelling a brick in Fusion 360:

And here is the online model: https://a360.co/3dLLBre

I still have problems with lighting and materials when rendering, but hey, it’s good enough. A bad render isn’t going to cause the physical item to fail…

Some nice technical drawings:

Not sure how the difference in templates crept in…

And assembly animation for the win \(^ヮ^)/

There should have been a video here but your browser does not seem to support it.

Deno, WASM and Rust projects with GitHub Actions

hello.vectronic@gmail.com (vectronic) — Tue, 05 Jul 2022 00:00:00 +0000

Presenting a set of template Rust, WASM and Deno projects on GitHub which make use of GitHub Actions and Workflows for continuous integration.

I’ve previously outlined my reasons for evaluating Rust and Deno. Using these technologies, I am looking to achieve:

A scriptable high-level layer (Deno REPL) controlling a performant lower-level core (Rust).
A single executable binary via Deno Compile.
Cross platform executables via cross-compilation support for Deno and Rust.
Ability to dynamically load and run additional logic after installation via Deno’s support for the Javascript import() function.
Agnostic support for running as an OS process or in a browser runtime via Deno’s web platform APIs and the ability to compile Rust to WASM.
Simple project scaffolding via Deno’s stated goal to “provide built-in tooling to improve developer experience”.

I wanted to see if these could all be achieved using free SaaS tooling for continuous integration including:

code analysis
automated dependency updates
automated unit testing and integration/acceptance testing
automated semantic releases
automatically generated API documentation

I created the template projects and GitHub workflow and actions discussed here to see if the technologies could deliver on their promises and thus achieve my aims.

I should state that I defaulted to using GitHub simply because I have been using it for several years now. Beyond recent FOSS concerns in the news I haven’t discovered any functional deficiencies which have caused me to look elsewhere.

Features

Before getting into details (and the inevitable pain points), some of the feature highlights I’ve managed to achieve are:

A single executable available for Linux, MacOS and Windows with the same functionality also running in a browser.
Instrumented test coverage analysis
Working example projects with GitHub actions for testing, compiling, versioning and releasing for:
- Rust
- Deno
- Rust + Deno via FFI Bindings
- Rust + Deno via WASM
Automated PRs, testing, merging, versioning and releasing for internal and 3rd party dependencies
Automatically updated API documentation

Repositories

The GitHub repositories involved in this effort are as follows:

“Application” Projects

flowscripter/template-deno-executable: Project template for a Deno executable.
flowscripter/template-deno-webapp: Project template for a Deno based webapp with Deno and Rust based WASM library dependencies.

“Simple Library” Projects

flowscripter/template-deno-library: Project template for a Deno library.
flowscripter/template-rust-library: Project template for a Rust library.

“Glue Library” Projects

flowscripter/template-deno-rust-library: Project template for a Rust library with Deno FFI bindings.
flowscripter/template-wasm-rust-library: Project template for a Rust library compiled to WASM.
flowscripter/template-deno-wasm-rust-library: Project template for a Rust library compiled to WASM exposed as a Deno module.

“CI” Projects

flowscripter/.github: GitHub Actions and Workflow Templates

A picture is worth a 1000 words… or maybe its just confusing…

It’s big and complex, but I hope the following describes things visually. It shows the projects (together with their artifacts and inter-dependencies) and various good and bad things to note.

Click on it to open in a larger form.

Flowscripter CI - click to enlarge

Eclectic Mix of Workarounds

Beyond some outstanding issues outlined further below, there were a few things I discovered which are worth noting:

.github v1 branch

As far as I am aware, the best approach to managing versioning of GitHub Actions in your own .github repository without publishing them is to use branches for versioning.

Each time I push a new commit to flowscripter/.github which involves an Action fix, I re-create the branch v1 on the .github repository so that the updated Action implementation will be used by dependent repositories.

As an example, the reference to the Action release_deno_library in the template-deno-library project is:

flowscripter/.github/actions/release-deno-library@v1

GitHub Pages to host WASM library releases

I used GitHub Pages to host a demo of the webapp.

I also ended up using it as a poor-man’s “artifact repository” for hosting pure Javascript Modules which include WASM files. I tried solutions like esm.sh and unpkg.com however:

These require opting back into the NodeJS+NPM package ecosystem (something I was trying to opt OUT OF by using Deno)
It seemed there was nothing available which supported serving WASM files with the mime-type expected by Deno when it fetches WASM files within the modules created with wasm-pack.

Reliance on Node and NPM

The semantic-release project is excellent. However it is written using Node and NPM. I’d love to find GitHub Actions which fully wrap this functionality or a single executable which doesn’t require an npm install which kind of goes against the grain when trying to migrate to Deno…

Following on from this, the semantic release plugin @qiwi/semantic-release-gh-pages-plugin expects the project being released to be Node based and therefore expects a package.json file to exist in the repository. Therefore, as part of releasing a WASM compiled library to GitHub pages, I need to:

perform an npm install so that the @qiwi/semantic-release-gh-pages-plugin works
remove the generated package.json BEFORE the semantic-release-rust tool is used to perform a Cargo publish (Cargo doesn’t like files which aren’t in Git when publishing).

The fact that this is a workaround for publishing to GitHub Pages which is in itself a workaround for hosting WASM library releases really does bite…

Git Update of Main Branch

I wanted to apply branch permissions for ALL users, including administrators of the repositories.

However, for Rust based repositories, the release number needs to be set in the cargo.toml file when performing the release from the main branch.

To achieve this, I needed the GitHub Action to be able to push directly to the main branch.

Thus I needed a Personal Access Token which will only work if administrators (i.e. myself) ARE NOT included in branch permissions…

Bleeding Edge

Whilst writing this blog entry, the Actions making use of deno_bindgen stopped working due to this issue:

https://github.com/denoland/deno_bindgen/issues/80

If you play with unstable APIs you’re gonna get hurt…

Outstanding Issues

The items I discovered which are blockers for my stated aims are as follows:

Dynamic Import of WASM based Javascript Modules

As far as I can tell, I can’t use dynamic imports (i.e. the Javascript import() function) with WASM based Javascript Modules until this is implemented: https://github.com/denoland/deno/issues/2552

Deno Compile support for dynamic imports

Deno supports:

compilation to a single binary executable \(^ヮ^)/
dynamic imports i.e. the Javascript import() function \(^ヮ^)/

However it doesn’t support both of these at the same time: https://github.com/denoland/deno/issues/8655 (>_<)

deno_bindgen updated to support the latest unstable Deno API

I mentioned this earlier as a downside to being on the bleeding edge: https://github.com/denoland/deno_bindgen/issues/80

Automatic Rust API docs for projects using `deno_bindgen`

Glue technologies like deno_bindgen are excellent, however I seem to be ‘stuck’ with this: https://github.com/denoland/deno_bindgen/issues/72

Without a change here, my automatically generated docs at https://docs.rs will continue to throw a massive error.

Deno signing and notarisation support

It’s not great delivering a single binary executable if the OS is reticent to run it… https://github.com/denoland/deno/issues/11154

GitHub Actions support for Apple Silicon

Not major, but until this is available I can’t fully implement cross-platform CI: https://github.com/actions/virtual-environments/issues/2187

Feedback

If anyone is interested in this and has actually read this far, I would love some feedback on:

suggested improvements or recommendations
any issues discovered

Legify 0.4.0

hello.vectronic@gmail.com (vectronic) — Mon, 21 Feb 2022 00:00:00 +0000

A new feature release version of Legify is available at:

https://github.com/vectronic/freecad-legify-macros/releases/tag/v0.4.0

This provides a new legify-technic-pin macro which renders a technic pin onto an existing Part Design workbench body.

Therefore the “s” in the name of the project “freecad-legify-macros” now has real meaning! 😜

3D Printed Brick Assemblies

hello.vectronic@gmail.com (vectronic) — Mon, 17 Jan 2022 00:00:00 +0000

I ordered some 3D prints of bricks designed with the legify macro code available at:

https://github.com/vectronic/freecad-legify-macros

Presented below are two assemblies as rendered within FreeCAD and assembled in real life.

Playing around with the physical prints it is obvious that they don’t ‘stick’ together anywhere near as well as the real thing.

Taking various measurements it seems that the quoted print accuracy of ±0.3% (min: ±0.15mm) really does come into play. Given the various dimensions used in the models it is obvious that a minimum error of 0.15mm will have a significant impact on some of the features.

It looks like I will need to start exploring CNC machining sooner than expected if I want to achieve accuracy around ±0.05mm.

I might also need a better setup for macro photography!

Legify 0.3.0

hello.vectronic@gmail.com (vectronic) — Wed, 17 Nov 2021 00:00:00 +0000

A new feature release version of Legify is available at:

https://github.com/vectronic/freecad-legify-macros/releases/tag/v0.3.0

Beyond a number of measurement improvements, rendering of technic pins is now implemented.

The latest macro code, brief overview and instructions are available at:

https://github.com/vectronic/freecad-legify-macros

NOTE: Be aware that due to this bug in FreeCAD discovered while implementing technic pin support, multiple technic pins will not render correctly at the moment.

New FreeCAD Assembly Render and Animation

hello.vectronic@gmail.com (vectronic) — Thu, 21 Oct 2021 00:00:00 +0000

I have just completed the finishing touches on Technic pin support:

There were a few potholes encountered on the journey and as always, they were solved with excellent community support:

As I now have pins available in my assemblies, I was able to try out the animation support within the Assembly4 Workbench:

There should have been a video here but your browser does not seem to support it.

I will be pushing the Technic pins support and various improvements in the next couple of days to:

https://github.com/vectronic/freecad-legify-macros

Recent FreeCAD Macro Lessons

hello.vectronic@gmail.com (vectronic) — Tue, 31 Aug 2021 00:00:00 +0000

I’ve been developing a FreeCAD macro for a while which uses the PartDesign workbench: https://github.com/vectronic/freecad-legify-macros

I’m just wrapping up support for rendering technic pins (work in progress screenshot below) and this effort has led me to a few more nuggets of information relating to PartDesign and Python scripting in FreeCAD.

Additive Pipe With Path and Profile Sketches

Developing the flange on the pin seen below introduced me to AdditivePipe and the fact that two sketches were required for a single feature.

Sample code snippet:

pin_pipe_path_sketch = body.newObject("Sketcher::SketchObject","pin_pipe_path_sketch")
pin_pipe_path_sketch.Support = (flange_path_sketch_plane, '')
pin_pipe_path_sketch.MapMode = 'FlatFace'

pin_pipe_profile_sketch = body.newObject("Sketcher::SketchObject", "pin_pipe_profile_sketch")
pin_pipe_profile_sketch.Support = [(pin_pipe_path_sketch, 'Edge1')]
pin_pipe_profile_sketch.MapMode = 'ObjectXZ'

pin_pipe = body.newObject("PartDesign::AdditivePipe", "pin_pipe")
pin_pipe.Profile = pin_pipe_profile_sketch
pin_pipe.Spine = pin_pipe_path_sketch

As seen in the code snippet above, I also needed to use a new MapMode. I had previously been using MapMode = 'FlatFace' by default everywhere. Now I have a new level of understanding on just what MapMode means…

Sketch Placement and Rotation

When the same feature was needed on different sides of the brick (e.g. a stud on the front side and on the left side of a brick) I had been relying on the fact that I was creating sketches programmatically.

In other words, a sketch for the front side stud would be created with different parts and constraints to that for the left side stud e.g. a horizontal LineSegment in place of a vertical LineSegment.

However, this approach fell apart for the notch sketch as I was struggling to get the constraint solver to work for each of the four different directions in which these sketches needed to be created. I nearly ended up writing four completely separate chunks of code to create the same sketch shape: one for each direction.

Clearly a better approach was needed, and obviously, FreeCAD provides one!

The new, better and correct approach is to create the same sketch for all four directions, but to rotate the Placement of the sketch depending on the direction.

Sample code snippet:

label = "right"
rotation = 270
pin_notch_sketch = body.newObject("Sketcher::SketchObject", label + "_pin_notch_sketch")
pin_notch_sketch.Support = [(datum_point, '')]
pin_notch_sketch.MapMode = 'Translate'
pin_notch_sketch.Placement = Placement(Vector(0, 0, 0), Rotation(Vector(0, 0, 1), rotation))

An example of two sketches, created by the same code, but rotated differently:

Body.Tip Gotcha

And finally, a ’tip’ about Body.Tip.

On most features, the following code will update the Body.Tip to the new feature:

pin_pipe = body.newObject("PartDesign::AdditivePipe", "pin_pipe")

However, for some reason (unknown to me), this will not update the Body.Tip when adding particular features such as a LinearPattern or Mirrored.

Instead, the following WILL update the Body.Tip:

pin_linear_pattern = doc.addObject("PartDesign::LinearPattern", "pin_linear_pattern")
body.addObject(pin_linear_pattern)

A successfully applied LinearPattern with the Body.Tip updated:

A Successfully Rendered FreeCAD Assembly

hello.vectronic@gmail.com (vectronic) — Tue, 30 Mar 2021 00:00:00 +0000

I reached a milestone last weekend with a successful render of a brick assembly in FreeCAD.

All brick models were created with the legify macro code available at:

https://github.com/vectronic/freecad-legify-macros

Thanks to some excellent FreeCAD developers I was able to create the assembly using Assembly4 Workbench and then render using Render Workbench.

I’ve created a zip of all the model files and below are some highlight renders and tech draw workbench diagrams.

This was all done using the instructions I posted previously for getting the latest version of FreeCAD on Big Sur running with the Render Workbench (with rendering performed by Cycles).

For reference, the FreeCAD details used for this:

OS: macOS 10.16
Word size of OS: 64-bit
Word size of FreeCAD: 64-bit
Version: 0.20.24511 (Git)
Build type: Release
Branch: master
Hash: efa19683aee7fdcf4efbdec81acb0c947ee46f9b
Python version: 3.8.8
Qt version: 5.12.5
Coin version: 4.0.0
OCC version: 7.4.0
Locale: English/United Kingdom (en_GB)

Building FreeCAD on macOS Big Sur

hello.vectronic@gmail.com (vectronic) — Mon, 15 Feb 2021 00:00:00 +0000

Presented here is a somewhat terse step-by-step guide to installing a working version of FreeCAD 0.19 on macOS Big Sur using Conda.

Additional bonus steps explain how to use the new FreeCAD Extension Manager to install the Assembly4 Workbench and the Render Workbench (with rendering performed by Cycles).

If you use a 3DConnextion SpaceMouse I can report these steps will produce a build which supports it.

The steps below are based on my initial post but updated to support the latest version of FreeCAD 0.19 and Big Sur and to incorporate my further understanding of how this all works. Credit also goes to useful information from DrVAX’s blog post and many contributions on this forum thread.

NOTE 1: These instructions worked using macOS Big Sur 11.2.1 with code repositories and release artifacts available on Feb 15 2021. Your results may vary depending on when you attempt these instructions and what version of macOS is installed …

NOTE 2: I am not sure if this is necessary, but to avoid confusion, before starting, I removed the following items from my system which I had previously installed:

XCode.app was removed by deleting it from the /Applications folder.
XCode CommandLineTools was removed by deleting it from the /Library/Developer folder.
Brew was removed via /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/uninstall.sh)"

You do not necessarily need to do the above, but if you are having any issues with the instructions below, maybe try removing some of these if they are already installed…

Also, XCode CommandLineTools is required later, so instructions to install this do appear further below at the appropriate place.

NOTE 3: To avoid confusion, all instructions are executed within the initially created Conda environment so that there should be minimal dependency on pre-installed build tools etc.

Install 3DConnexion drivers

Download and install the beta driver for macOS Big Sur.

Install miniconda

cd /tmp
curl -L -O https://repo.continuum.io/miniconda/Miniconda3-latest-MacOSX-x86_64.sh
bash Miniconda3-latest-MacOSX-x86_64.sh -b

NOTE: Replace <home> below with your home directory e.g. /Users/vectronic or possibly $HOME:

echo ". <home>/miniconda3/etc/profile.d/conda.sh" >> ~/.bash_profile

Close and restart your terminal.

Prepare Conda environment

conda create -n freecad_0_19 -y
conda activate freecad_0_19

From now on, all instructions should be performed within the activated freecad_0_19 environment. If you open a new terminal to carry on, or whenever you want to run FreeCAD, you will first need to run:

conda activate freecad_0_19

DrVax provides helpful instructions on how the final installed freecad executable can be run as a macOS application. See “Creating a macOS Application from a Conda Installation” on this page.

Install FreeCAD

conda install -c freecad/label/dev freecad -y
conda install libclang=9.0.1 -y

The libclang command is a workaround for problems launching FreeCAD on Big Sur.

See if it works

Start FreeCAD:

freecad

If FreeCAD starts up (and doesn’t hang), things are looking good…

Exit FreeCAD and go back to the freecad_0_19 Conda environment in the terminal.

Install Xcode command line tools

Trigger the installation with:

xcode-select --install

Follow the instructions and once installed make sure they are in use:

sudo xcode-select -s /Library/Developer/CommandLineTools

Install Extension Manager workbench

mkdir ~/Library/Preferences/FreeCAD/Mod
cd ~/Library/Preferences/FreeCAD/Mod
git clone https://github.com/mnesarco/FreeCAD_ExtMan.git ExtMan

Install cycles standalone

conda install svn cmake -y
cd /tmp
mkdir cycles
cd cycles
mkdir lib
cd lib
svn checkout -r 62553 https://svn.blender.org/svnroot/bf-blender/trunk/lib/darwin
cd ..
git clone git://git.blender.org/cycles.git
cd cycles

Edit src/cmake/Modules/FindOpenImageIO.cmake and change line 70 from TRUE to FALSE e.g.

SET(OPENIMAGEIO_PUGIXML_FOUND FALSE)

Edit src/cmake/external_libs.cmake and change line 235 from PugiXML to PUGIXML e.g.

find_package(PUGIXML REQUIRED)

Then:

PUGIXML_ROOT_DIR=/tmp/cycles/lib/darwin/pugixml make
cp bin-opt/bin/cycles ~/miniconda3/envs/freecad_0_19/bin/

FreeCAD configuration

Start FreeCAD:

freecad

Install Assembly4 using Extension Manager Workbench

Go to View->Workbench->Extension Manager.
Select Add (Download) and then Addons.
Look in the Assembly section for Assembly4 and click Install.
Confirm Install.

Install Render Workbench using Extension Manager Workbench

Go back to Add (Download) and then Addons.
Look in the Uncategorized section for Render and click Install.
Confirm Install.

Restart FreeCAD.

Configure Render Workbench to use Cycles

Load the Render workbench: View->Workbench->Render (this might hang for a bit…).
Configure the render workbench via freecad->Preferences->Render and set:
- Cycles executable path to cycles
- Render parameters to --samples 500 --background

Test Part Design model render

Download this sample part design model and open it in FreeCAD.
Create a render project via Render->Cycles Project and selecting the cycles_sunlight.xml file.
Change the Angular Deflection data property of the Cycles Project from 0.52 to 0.1.
In the tree navigation, select the brick->top_studs_inside_pocket AND the Cycles Project.
Create a render view via Render->Create View.
Ensure the view is set to perspective via View->Perspective View.
Select the Cycles Project in the tree navigation.
Render via Render->Render (this will hang for a bit… you can see progress in the terminal where you launched FreeCAD).

You should end up with a rendered image similar to this:

Test Assembly4 model render

Download this sample assembly4 model and open it in FreeCAD.
Create a render project via Render->Cycles Project and selecting the cycles_sunlight.xml file.
Change the Angular Deflection data property of the Cycles Project from 0.52 to 0.1.
In the tree navigation, select the Model AND the Cycles Project.
Create a render view via Render->Create View.
Ensure the view is set to perspective via View->Perspective View.
Select the Cycles Project in the tree navigation.
Render via Render->Render (this will hang for a bit… you can see progress in the terminal where you launched FreeCAD).

You should end up with a rendered image similar to this:

Migrate to Deno?

hello.vectronic@gmail.com (vectronic) — Fri, 08 Jan 2021 00:00:00 +0000

The plan for Flowscripter has always included the following goals:

Use TypeScript.
Use dynamic import of ES modules.
Rely on existing module dependency directives to auto-install plugin dependencies i.e. not inventing a new module dependency framework.
Providing Flowscripter as a single downloadable binary with no need for pre-installed dependencies e.g. Node.js, ffmpeg.
Support native extensions written in Rust.

To meet these requirements Flowscripter started with:

TypeScript running on Node.js.
Requiring Node.js 10.x onwards which had the first experimental support for ES modules.
The esm-dynamic-plugins library made use of the npmjs.com repository and Node.js package.js definitions. For browser runtimes, using https://unpkg.com was the intention.
The intention was to use nexe to build a single distributable binary.
The intention was to use NodeJS N-API C++/C addon support and develop Rust based native add-ons as per this tutorial.

Of course with the above technologies, came the usual (and painful) need to configure and debug a build toolchain providing TypeScript, a test framework (Jest), a packaging system (RollupJs) and a documentation generator (TypeDoc).

More difficult was the need for these tools to support ES modules natively (or via transpiling) and for the Flowscripter ES Modules to depend on existing non-ES module NodeJS packages …. I think I spent just as much time getting the toolchain working together as I did writing ‘actual code’…

Although, the Flowscripter ‘actual code’ it still in a state of infancy, the main concerns so far with the above are the following:

Making use of the NodeJS package.json and npm repository either necessitated:
- Calling out to a locally installed npm thereby defeating the purpose of a single installable binary.
- Importing the underlying npm implementation: a horrible rabbit hole I discovered and then exited!
- Implementing support from scratch - which was done but with some severe limitations (see here and here).
Despite the excellence of nexe, support for native addons, externally sourced modules and ESM modules still seems to be work in progress… see here, here and here.

Around the time of starting out on Flowscripter I had seen the announcement of Deno. Obviously bleeding edge would have been an understatement at that point…

However, since then, time has passed (mostly working on the toolchain issues mentioned above, or more importantly on actual paid work….) and Deno v1 has been released.

It’s tempting. Let’s review given the initially stated Flowscripter goals and the current concerns for the Node.js based implementation:

TypeScript ✅
ES Modules ✅
Rust plugins ✅
Compiled executables ✅
Simple dependency mechanism ✅

Additionally, the support for importing a module from a URL would (hopefully) completely obviate the need for esm-dynamic-plugins to implement separate a UrlPluginRepository.ts and NodeModulesPluginRepository.ts.

Of course there are arguments against Deno. These are mostly based on it’s relative immaturity. Fair enough, you don’t want to back the wrong horse… And also is it really ready for production?

To answer that, I’m going to take some time out to do an analysis of whether the above mentioned features can currently meet the Flowscripter goals and my concerns on the current path taken. Findings to follow….

P.S. I’m also going to take time to make use of the fact that GitHub seems to be swallowing the CI/CD world. Hence I’m planning to port away from npmjs.com (well maybe with Deno this won’t be relevant - any hoo…), Travis and Renovate and use GitHub for everything.

Legify 0.2.2

hello.vectronic@gmail.com (vectronic) — Sun, 02 Aug 2020 00:00:00 +0000

A bugix version of Legify is available at:

https://github.com/vectronic/freecad-legify-macros/releases/tag/v0.2.2

It provides improvements to measurements and rendering based on using the macro generated parts in Assembly V4 and TechDraw workbenches.

Example TechDraw diagrams for individual parts and assemblies are provided below.

The latest macro code, brief overview and instructions are available at:

https://github.com/vectronic/freecad-legify-macros

FFmpeg now supports ICC Profiles in MP4

hello.vectronic@gmail.com (vectronic) — Mon, 16 Mar 2020 00:00:00 +0000

Last year I provided some FFmpeg patches to support ICC Profiles stored within MP4 (and MOV) files.

The patches were recently merged into master and will therefore be available in the next FFmpeg release.

\( ﾟヮﾟ)/

ICC profiles can be stored in MOV/MP4 sample descriptor colour information atoms. The relevant extract from the ISO standard is:

class ColourInformationBox extends Box('colr'){
    unsigned int(32) colour_type;
    if (colour_type == 'nclx')  /* on-screen colours */
    {
        unsigned int(16) colour_primaries;
        unsigned int(16) transfer_characteristics;
        unsigned int(16) matrix_coefficients;
        unsigned int(1)  full_range_flag;
        unsigned int(7)  reserved = 0;
    }
    else if (colour_type == 'rICC')
    {
        ICC_profile;    // restricted ICC profile
    }
    else if (colour_type == 'prof')
    {
        ICC_profile;    // unrestricted ICC profile
    }
}

FFmpeg already had support for the nclx colour type, but my use case was to support the prof colour type.

Additionally, ICC profile support was already available on a per frame basis in AVFrameSideDataType.AV_FRAME_DATA_ICC_PROFILE. This is used by the PNG, WEBP and MJPEG codec implementations. This support was not sufficient however as the MOV/MP4 sample descriptor relates to the entire stream and not on a per-frame basis.

Changes

The changes required were to:

add a new enum value AV_PKT_DATA_ICC_PROFILE to AVPacketSideDataType
add reading support to the MP4 demuxer
add writing support to the MP4 muxer

The last item included adding a movflag prefer_icc to ensure backwards compatible behaviour of the existing write_colr movflag.

Usage

Here is a small example file with an ICC Profile embedded: icc-profile.mp4

With the above changes in place and using the sample file, when you execute ffprobe you will see the output includes a new side data entry of ICC Profile:

% ./ffprobe -hide_banner icc-profile.mp4
Input #0, mov,mp4,m4a,3gp,3g2,mj2, from 'icc-profile.mp4':
  Metadata:
    major_brand     : mp42
    minor_version   : 1
    compatible_brands: mp41mp42isom
    creation_time   : 2019-09-19T08:13:20.000000Z
  Duration: 00:00:00.08, start: 0.000000, bitrate: 32519 kb/s
    Stream #0:0(und): Video: hevc (Main) (hvc1 / 0x31637668), yuv420p(tv, progressive), 3440x1440 [SAR 1:1 DAR 43:18], 31699 kb/s, 60 fps, 60 tbr, 600 tbn, 600 tbc (default)
    Metadata:
      creation_time   : 2019-09-19T08:13:20.000000Z
      handler_name    : Core Media Video
    Side data:
      ICC Profile

When remuxing an MP4, the following will preserve the ICC profile in the output:

./ffmpeg -i icc-profile.mp4 -movflags write_colr+prefer_icc -c:v copy out.mp4

Legify 0.2.0

hello.vectronic@gmail.com (vectronic) — Sun, 15 Mar 2020 00:00:00 +0000

The latest and most likely last version of Legify is available at:

https://github.com/vectronic/freecad-legify-macros/releases/tag/v0.2.0

I’ve achieved my goals with this project, which were to:

Get to grips with FreeCAD and parametric modelling concepts: sketches, constraints, datum planes etc.
Learn Python and use it for FreeCAD scripting

I’m now moving on to learn about assemblies and technical drawings.

The latest macro code, brief overview and instructions are available at:

https://github.com/vectronic/freecad-legify-macros

Measurement of Lego Brick Dimensions

hello.vectronic@gmail.com (vectronic) — Mon, 01 Jul 2019 00:00:00 +0000

As part of my efforts to accurately model Lego bricks, I need to visualise the finer features of Lego pieces and measure various dimensions accurately.

I’ve been making measurements using the following microscopy setup:

Measurements were made using a calibrated scale of 0.1mm:

Here is a good example of the usefulness of this approach over measurement by hand with a micrometer:

So far, two bricks have been regrettably sacrificed to obtain some internal dimensions:

All photos are posted to my Lego Measurement Pinterest board.

Stay tuned for a new release of Legify with new features incorporating these measurements.

Timecodes in Excel without Macros

hello.vectronic@gmail.com (vectronic) — Mon, 17 Jun 2019 00:00:00 +0000

Googling for “excel timecode” didn’t produce any results which met my requirements:

support 29.97 drop-frame SMPTE timecode
calculate a duration given an in-point and out-point
provide conversion to and from timecode, frame count and microseconds
not based on Excel macros so that the solution can be easily redistributed

Because of this, I am pleased to present a solution which does meet the above requirements:

https://github.com/vectronic/timecode-spreadsheet

Building FreeCAD Assembly3 on macOS using Conda

hello.vectronic@gmail.com (vectronic) — Thu, 13 Jun 2019 00:00:00 +0000

I have moved on from learning basic part design and scripting in FreeCAD and now want to tackle assemblies.

Following on from my previous post, Building FreeCAD with 3DConnexion Support on macOS using Conda, this post presents similar instructions for building the very promising Assembly3 Workbench for FreeCAD.

Again, I wanted to use the latest source AND use a 3DConnexion SpaceMouse on a MacBook Pro. Using Conda and the Conda Forge feedstock for FreeCAD makes this a scriptable, repeatable process.

Install 3DConnexion Drivers

Download and install the latest driver for macOS.

Install miniconda

curl -L -O https://repo.continuum.io/miniconda/Miniconda3-latest-MacOSX-x86_64.sh
bash Miniconda3-latest-MacOSX-x86_64.sh -b
rm Miniconda3-latest-MacOSX-x86_64.sh 
echo ". ~/miniconda3/etc/profile.d/conda.sh" >> ~/.bash_profile

Install MacOSX10.9.sdk

curl -L -O https://github.com/phracker/MacOSX-SDKs/releases/download/10.13/MacOSX10.9.sdk.tar.xz
sudo tar -C /opt/ -xf MacOSX10.9.sdk.tar.xz 
rm MacOSX10.9.sdk.tar.xz

Set SDK location for Conda

echo "CONDA_BUILD_SYSROOT:" > ~/conda_build_config.yaml
echo "   - /opt/MacOSX10.9.sdk  # [osx]" >> ~/conda_build_config.yaml

Link to SDK for Circle CI based support scripts

mkdir -p /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/
ln -s /opt/MacOSX10.9.sdk /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs

Prepare Conda environment

conda create -n freecad_ass3 -y
conda activate freecad_ass3
conda config --add channels conda-forge
conda install conda-build -y

Get FreeCAD feedstock

git clone https://github.com/conda-forge/freecad-feedstock
cd freecad-feedstock/

Point to the Assembly3 FreeCAD Fork

The FreeCAD feedstock recipe needs to be modified to use realthunder’s FreeCAD Fork.

Edit recipe/meta.yaml and edit the following:

the version variable: {% set version = "LinkStage3" %}
the git_url variable: git_url: https://github.com/realthunder/FreeCAD.git

Build FreeCAD

conda build ./recipe -m ./.ci_support/osx_python3.7.yaml

Workaround failing tests

The build will finally fail with a message similar to:

Tests failed for freecad-LinkStage3-py37h7748daf_1.tar.bz2 - moving package to /Users/vectronic/miniconda3/envs/freecad_ass3/conda-bld/broken

The failed tests don’t seem to stop basic functionality working in FreeCAD and realthunder is planning to eventually fix them. In the meantime I ignore them as follows:

mv ~/miniconda3/envs/freecad_ass3/conda-bld/broken/freecad-LinkStage3-py37h7748daf_1.tar.bz2  ~/miniconda3/envs/freecad_ass3/conda-bld/osx-64/
conda index ~/miniconda3/envs/freecad_ass3/conda-bld

Install FreeCAD

conda install -c file://${CONDA_PREFIX}/conda-bld/ freecad=LinkStage3 -y

Install and build the Assembly3 workbench and constraint solver

conda install swig -y

cd ~/miniconda3/envs/freecad_ass3/Ext/freecad
git clone https://github.com/realthunder/FreeCAD_assembly3.git
mv FreeCAD_assembly3 asm3
cd asm3

git checkout f66358d
git submodule update --init slvs
cd slvs
git submodule update --init --recursive

mkdir build
cd build
cmake -DCMAKE_BUILD_TYPE=Release -DBUILD_PYTHON=1 ..
make _slvs

cd ../..
touch py_slvs_mac/__init__.py
cp slvs/build/src/swig/python/_slvs.so py_slvs_mac/
cp slvs/build/src/swig/python/slvs.py py_slvs_mac/

cd py_slvs_mac
install_name_tool -id "_slvs.so" _slvs.so
install_name_tool -add_rpath "@loader_path/../../../../lib/" _slvs.so

install_name_tool -change "~/miniconda3/envs/freecad_ass3/lib/libpython3.7m.dylib" "@rpath/Python" _slvs.so

NOTE: If the last command didn’t work as the python library version has changed, run the following to see which library to relink to:

otool -L _slvs.so

Use it!

FreeCAD

First Microscopic Soldering Project

hello.vectronic@gmail.com (vectronic) — Mon, 10 Jun 2019 00:00:00 +0000

My first serious microscopic soldering project took place over the weekend!

An Intel NUC had been prised open during a baggage inspection. Thanks TSA!

As a result the fan connector had been torn from the PCB.

I’m not saying it was a nicely executed repair, but the NUC does now work… Identified areas for improvement:

an improved solder flux situation: my 0.2mm solder didn’t want to flow onto anything, the thicker solder dumped a pool of flux eveywhere.
an improved glueing mechanism: again, I ended up with a pool of super glue…
improved software settings for the microscope’s USB camera: the photos don’t do justice to the stunning clarity I had through the eye pieces.
a PCB cleaning mechanism.

Firstly, the workstation setup:

The damage inflicted on the innocent electronics:

A messy scrape to discover and expose some tracks which hadn’t been ripped off:

Rewired links (and that pool of flux):

A big dollop of epoxy resin glue to hold the fan connector down:

A zoomed out view of the completed repair:

Building FreeCAD with 3DConnexion Support on macOS using Conda

hello.vectronic@gmail.com (vectronic) — Sat, 04 May 2019 00:00:00 +0000

Presented here is a somewhat terse step-by-step guide to building FreeCAD from source using Conda and the Conda Forge feedstock for FreeCAD.

I need to do this to ensure I can run the latest FreeCAD code AND use a 3DConnexion SpaceMouse on a MacBook Pro.

The steps below were compiled through trial and error, much hair-pulling and extraction of useful information from here, here and here.

Install 3DConnexion Drivers

Download and install the latest driver for macOS.

Install miniconda

NOTE: Replace <home> below with your home directory e.g. /Users/vectronic or possibly $HOME.

curl -L -O https://repo.continuum.io/miniconda/Miniconda3-latest-MacOSX-x86_64.sh
bash Miniconda3-latest-MacOSX-x86_64.sh -b
rm Miniconda3-latest-MacOSX-x86_64.sh 
echo ". <home>/miniconda3/etc/profile.d/conda.sh" >> ~/.bash_profile

Install MacOSX10.9.sdk

curl -L -O https://github.com/phracker/MacOSX-SDKs/releases/download/10.13/MacOSX10.9.sdk.tar.xz
sudo tar -C /opt/ -xf MacOSX10.9.sdk.tar.xz 
rm MacOSX10.9.sdk.tar.xz

Set SDK location for Conda

echo "CONDA_BUILD_SYSROOT:" > ~/conda_build_config.yaml
echo "   - /opt/MacOSX10.9.sdk  # [osx]" >> ~/conda_build_config.yaml

Link to SDK for Circle CI based support scripts

mkdir -p /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/
ln -s /opt/MacOSX10.9.sdk /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs

Prepare Conda environment

conda create -n freecad_0_18_1 -y
conda activate freecad_0_18_1
conda config --add channels conda-forge
conda install conda-build -y

Get FreeCAD feedstock

git clone https://github.com/conda-forge/freecad-feedstock
cd freecad-feedstock/

Build FreeCAD

conda build ./recipe -m ./.ci_support/osx_python3.7.yaml

NOTE: I found it wasn’t necessary to add -D FREECAD_USE_3DCONNEXION=ON to recipe/build.sh as the build seemed to pick up the presence of the installed driver and use it by default.

NOTE: To modify the version of FreeCAD which is build, edit recipe/meta.yaml and change the version variable e.g.:

{% set version = "master" %}

Install FreeCAD

conda install -c file://${CONDA_PREFIX}/conda-bld/ freecad=0.18.1 -y

NOTE: conda install --use-local freecad=0.18.1 didn’t seem to use the locally built package - possibly related to this reported issue.

Use it!

FreeCAD

Home Lab Fit-Out

hello.vectronic@gmail.com (vectronic) — Mon, 21 Jan 2019 00:00:00 +0000

I finished the DIY fit-out of my lab/office/study late last year.

A lot of planning and design was done before I started cutting into flat-pack furniture with the circular saw.

I’m very pleased with the result. This is a good thing as I’ll be spending a significant portion of my life for the coming years here.

The end result is pictured below and further work in progress shots are posted on Pinterest.

Legify 0.1.0

hello.vectronic@gmail.com (vectronic) — Fri, 18 Jan 2019 00:00:00 +0000

I’ve been developing a FreeCAD macro for a while with the following aims:

Get to grips with FreeCAD and parametric modelling concepts: sketches, constraints, datum planes etc.
Learn Python and use it for FreeCAD scripting

To really push the boundaries, I challenged myself to use Python scripting in conjunction with the PartDesign workbench: I wanted to end up with a parametric model fully based on sketches and datum planes.

The latest macro code, brief overview and instructions are available at:

https://github.com/vectronic/freecad-legify-macros

The very first v0.1.0 cut is available at:

https://github.com/vectronic/freecad-legify-macros/releases/tag/v0.1.0

I’ve learnt and discovered various things on this journey:

Example images below. Check it out and let me know what you think!

FreeCAD Part Design Indices

hello.vectronic@gmail.com (vectronic) — Sat, 05 Jan 2019 00:00:00 +0000

There are several limitations when referencing items in FreeCAD via Python script. This includes needing to reference Part items such as edges and faces by name, whilst the names are liable (and likely) to change each time the model is modified.

There are also a number of exposed native methods in the Python scripting layer which expect (rarely documented) integer based constants. In this post I collate what I’ve learnt about these constants for future reference.

Body Origin Axes and Planes

The Origin of a Part Design workbench Body called myBody can be acquired via:

origin = App.getDocument('Unnamed').getObject('myBody').Origin

The axes and planes for this Origin are available as OriginFeatures which can be identified as follows:

for feat in b.Origin.OriginFeatures:
	feat.Name

which outputs:

'X_Axis'
'Y_Axis'
'Z_Axis'
'XY_Plane'
'XZ_Plane'
'YZ_Plane'

Hence to get a reference to one of these you can iterate through OriginFeatures matching against the desired feature Name.

However if you want to live dangerously, you can rely on indexing into the array of OriginFeatures with these values:

ORIGIN_X_AXIS_INDEX = 0
ORIGIN_Y_AXIS_INDEX = 1
ORIGIN_Z_AXIS_INDEX = 2
ORIGIN_XY_PLANE_INDEX = 3
ORIGIN_XZ_PLANE_INDEX = 4
ORIGIN_YZ_PLANE_INDEX = 5

The risk here is that the native code layer OriginFeatures array order may change between FreeCAD releases.

Sketch Geometry and Constraints

Geometry Item Indices

Special indices are defined as follows:

Horizontal axis: -1
Vertical axis: -2
First external geometry construction item: -3.

Hence, external geometry constructions items in a sketch are indexed from -3 descending!

Vertex Indices

The start vertex of a geometry line segment has index 1 and the end vertex has index 2.

The centre vertex of a geometry circle is index 3.

Examples

Creating an DistanceX constraint between a line segment start and the origin point:

SKETCH_GEOMETRY_VERTEX_START_INDEX = 1
SKETCH_GEOMETRY_ITEM_HORIZONTAL_AXIS_INDEX = -1

my_constraint = Sketcher.Constraint("DistanceX",
                                    segment_index, SKETCH_GEOMETRY_VERTEX_START_INDEX,
                                    SKETCH_GEOMETRY_ITEM_HORIZONTAL_AXIS_INDEX, SKETCH_GEOMETRY_VERTEX_START_INDEX, 
                                    distance)

Creating a PointOnObject constraint between a line segment start and an external item used as a geometry construction item:

SKETCH_GEOMETRY_VERTEX_START_INDEX = 1
SKETCH_GEOMETRY_FIRST_CONSTRUCTION_INDEX = -3

my_sketch.addExternal(my_datum_plane.Label, '')
my_constraint = Sketcher.Constraint("PointOnObject", 
                                    segment_index, SKETCH_GEOMETRY_VERTEX_START_INDEX, 
                                    SKETCH_GEOMETRY_FIRST_CONSTRUCTION_INDEX)

Creating a DistanceY constraint between the centre of a circle and the origin point:

SKETCH_GEOMETRY_VERTEX_START_INDEX = 1
SKETCH_GEOMETRY_VERTEX_CENTRE_INDEX = 3
SKETCH_GEOMETRY_ITEM_HORIZONTAL_AXIS_INDEX = -1

my_constraint = Sketcher.Constraint("DistanceY", 
                                    segment_index, SKETCH_GEOMETRY_VERTEX_CENTRE_INDEX, 
                                    SKETCH_GEOMETRY_ITEM_HORIZONTAL_AXIS_INDEX, SKETCH_GEOMETRY_VERTEX_START_INDEX, 
                                    distance)

PyCharm for FreeCAD Macro Development

hello.vectronic@gmail.com (vectronic) — Thu, 27 Dec 2018 00:00:00 +0000

Beyond simple scripts, FreeCAD macro development really benefits from using a Python IDE. My Python IDE of choice is PyCharm.

I have been able to setup the same Python environment with FreeCAD and PyCharm using this great project https://github.com/FreeCAD/FreeCAD_Conda.

This allows the same Python syntax and semantics to be applied (especially important when switching from Python 2 to Python 3). Unfortunately however, having code completion for FreeCAD modules still eludes me…

Installation

The following steps will get PyCharm and FreeCAD using the same Python installation.

NOTE: This was done on MacOS.

Install Miniconda

Download Miniconda installer from https://conda.io/miniconda.html and install it:

bash Miniconda3-latest-MacOSX-x86_64.sh 
echo ". /Users/vectronic/miniconda3/etc/profile.d/conda.sh" >> ~/.bash_profile

Create Conda Environment for FreeCAD

A Conda environment with FreeCAD can then be built with:

conda create -n freecad-0.18-mac freecad

Use FreeCAD

To use the FreeCAD binary built with Conda it needs to be launched from the terminal:

conda activate freecad-0.18-mac
FreeCAD

Inside the FreeCAD Python console you can then check the Python environment using:

import sys
print('Python %s on %s' % (sys.version, sys.platform))

Use Conda Environment in PyCharm

The same Conda environment can then be configured within your PyCharm project via the following GUI path:

PyCharm Preferences -> Project Interpreter -> Gear Icon -> Add -> Conda Environment -> Existing Environment

Choose the location of the Python executable from the Conda environment. In my case this is ~/miniconda3/envs/freecad-0.18-mac/bin/python.

Now from the PyCharm Python console you should get the same results as previously with:

import sys
print('Python %s on %s' % (sys.version, sys.platform))

Fail…

Despite the above and my endless attempts to configure dynamic library and module paths correctly, code completion just will not work. As far as I can tell it relates to an issue with how PyCharm handles processing of dynamic native libraries.

I don’t hold much hope of it being resolved:

https://youtrack.jetbrains.com/issue/PY-20463

Reloading FreeCAD Macro Code

hello.vectronic@gmail.com (vectronic) — Thu, 27 Dec 2018 00:00:00 +0000

I’ve been developing a fairly complex macro for FreeCAD and wanted to re-run it after making code changes without having to restart FreeCAD.

I found this forum posting which gave me the answer.

This post was discussing reloading code for workbenches and GUI Commands (which has some caveats) and it also works perfectly for macros.

I have a multi-file macro setup as discussed in this post. The entry point is a .FCMacro file with the following:

from Legify.Dialog import *
Dialog()

From within the FreeCAD Python console, the macro dialog can be displayed for the first time with:

>>> from Legify import Dialog
>>> Dialog.Dialog()

To reload and redisplay the dialog when code has been modified:

reload(Dialog); Dialog.Dialog()

If you need to update sub-modules, they need to be reloaded (as well as the parent module loading them) e.g.:

>>> from Legify import Brick; from Legify import Body
>>> reload(Body); reload(Brick); reload(Dialog); Dialog.Dialog()

NOTE: If you are using Python 3, you will first need to import the reload module:

from importlib import reload

Moderated Comments System on a Static HTML Website

hello.vectronic@gmail.com (vectronic) — Mon, 10 Dec 2018 00:00:00 +0000

This website is built using Hugo and deployed on Netlify. I’ve been very happy with both of these technologies since deciding to use them. I did find the Hugo documentation somewhat impenetrable: all the information and detail is there, but it’s a steep ol’ curve for a newcomer. I’ve surmounted that curve and this site now features statically hosted blog comments - including moderation functionality.

This post aims to step through the required config and to point out some salient points.

The general approach is inspired by the following article and accompanying sample project:

The configured system uses Netlify Forms and Functions add-ons. Both of these are free for low volume usage. Comment notification and moderation relies on Slack which is also free.

The source and full configuration instructions are available at:

https://github.com/vectronic/website

Integration Overview

Comment Submission

The following occurs when a user submits a comment via the comment form on a blog post page:

The form contents are posted to Netlify as the form has a netlify attribute and stored in a Netlify table called pending-comments.
The insertion of a table entry triggers a Netlify Lambda function called comment-submitted.
The Lambda function posts the comment data via the Slack API to a simple Slack App. My app is called vectronic-comment.
The Slack App posts the comment to a Slack channel with user actions provided to either “delete” or “approve” the comment. My channel is called #vectronic-comment.

Comment Moderation

The following occurs when a user action on a comment is clicked in the #vectronic-comment channel:

The user action invokes a Netlify Lambda function called comment-action.
1. If the action was “delete”, the function calls the Netlify API to delete the entry from the pending-comments table.
2. If the action was “approve”, the function calls the Netlify API to move the entry from the pending-comments table to the approved-comments table.

Approved Comment Publishing

Approved comments are rendered as static HTML as part of the Hugo site build. When a new comment is added to the approved-comments table the following occurs:

The insertion of a table entry triggers a Netlify build via a Build Hook.
The Netlify build runs a Gulp task which:
1. Uses the Netlify API to grab all of the approved comments from the approved-comments table.
2. The comments are placed in a map using the blog post as a key and written to a data file.
The Netlify build then runs Hugo which uses the data file as a data source for each of the generated post pages.

Configuration

Presented below is a fairly terse outline of the configuration required in Slack and Netlify.

Slack

Configure a Slack App for your workspace. Mine is called vectronic-comment.
Add an Incoming Webhook to the app which will post messages to a channel. My channel is called #vectronic-comment.
Enable Interactive messages on the app and configure a Request URL for the actions which invokes the Netlify Lambda function called comment-action. My URL looks like this (the shared secret is discussed further below:
```
 https://vectronic.io/.netlify/functions/comment-action?VECTRONIC_FUNCTION_AUTH=<shared secret>     
```
Install the app in your Slack workspace.

The above should allow posting comment details via the Slack API to a channel in your workspace. The comments will appear as interactive messages with actions to click on. Clicking an action will post back to the configured Netlify Function.

Netlify

One Time Only Table Creation

The Netlify tables that store data submitted from website forms are added to your website configuration upon the initial posting from a form. In our use case both forms (pending-comments and approved-comments) need to exist before we can do any further configuration:

Pending Comments

For the pending-comments table creation, just submit a test comment using your website comments form. Ensure the HTML form has a name of pending-comments and the attribute netlify set.

Once a test comment is posted, you should see a pending-comments table in the Netlify admin UI and will be able to configure notifications for it.

Refer to my website source for this here

Approved Comments

Entries in the approved-comments form table are only added via Slack integration calls to the Netlify Lambda function comment-action. But again, this table needs to be created in Netlify first so that notifications can be configured for it.

The easiest way to achieve this is to temporarily deploy a website page which contains an appropriate HTML form having a name of approved-comments and the attribute netlify set.

Once a test comment is posted, you should see an approved-comments table in the Netlify admin UI and will be able to configure notifications for it. The approved-comments HTML form can then be commented out or removed from your website source.

Refer to my website source for this here

User Account Level OAuth Token

At the user account level in Netlify, create a new OAuth application personal access token. Mine is called vectronic-comments-management. This Personal Access Token will be used when making calls to the Netlify API from Netlify Functions.

The Netlify Personal Access Tokens configuration page can be found here.

Build Environment Variables

The following should be defined as environment variables for the Netlify build environment so that sensitive information can be kept out of the website source:

NETLIFY_API_AUTH - The personal access token created in the Netlify OAuth applications section.
NETLIFY_APPROVED_COMMENTS_FORM_ID - The ID of the approved-comments form table created in Netlify. The value for this can be ascertained from the Netlify URL seen in the browser when navigating to:
```
  Account -> Site -> Forms -> approved-comments.
```
SLACK_COMMENT_WEBHOOK_URL - The incoming webhook URL provided for your Slack app when the Incoming Webhook was added to it.
VECTRONIC_FUNCTION_AUTH - This can be any shared secret key. It is used to prevent access to the publicly exposed Netlify Functions (more on this below).

The above can be set in the “Continuous Deployment” settings section of the Netlify website admin UI.

Build Hooks

Define a Build Hook which will be used to automatically rebuild the site when a new comment is approved. Mine is called build-vectronic.

The above can be set in the “Continuous Deployment” settings section of the Netlify website admin UI.

Form Notifications

Configure the following Outgoing Webhooks:

On a new form submission to the pending-comments form, post to the comment-submitted function configured in Netlify e.g.

https://vectronic.netlify.com/.netlify/functions/comment-submitted?VECTRONIC_FUNCTION_AUTH=
On a new form submission to the approved-comments form, post to the build hook configured in Netlify.

The above can be set in the Form notification settings section for your Netlify website.

Implementation

Presented below are the salient points of implementation that work in conjunction with the above configuration.

New Comment Form

The source for the website comment form pending-comments can be seen here

Functions

A large part of the action occurs in the implementation of the two Netlify Lambda functions:

I believe these are fairly self-explanatory. If they’re not, post me a comment!

Approved Comments Gulp Task

The logic to pull approved comments data from the Netlify approved-comments table is implemented in a Gulp task:

https://github.com/vectronic/website/blob/master/gulpfile.js

I believe this is fairly self-explanatory. If not, post me a comment!

Hugo Site Build

Netlify is configured to build the Hugo site via a netlify.toml file as follows:

gulp build:comments && hugo && npx netlify-lambda build src/functions

This build instruction performs three simple steps:

Pull down the approved comments data into a map structure written to file
Render the website reading data from the map file
Build the Lambda functions

Approved Comments Rendering

The source for the website rendering of approved comments can be seen here

Security

The Netlify Lambda functions comment-submitted and comment-action are both available for invocation via public URLs. As I don’t want anything apart from my website and my Slack account invoking them I have a simple shared secret check implemented:

// check auth
let queryStringParameters = event.queryStringParameters;
if (queryStringParameters["VECTRONIC_FUNCTION_AUTH"] !== process.env.VECTRONIC_FUNCTION_AUTH) {
    return console.log("VECTRONIC_FUNCTION_AUTH query param incorrect");
}

A Quick Note on Scale

I have previously read some criticisms of the approach described here with respect to its ability to scale e.g. many posts requiring many website rebuilds, the time taken to rebuild, the need to moderate each and every comment etc. etc. For me, with currently around 4 posts and 0 comments, its fair to say this isn’t a concern. I will be happy when it does become a concern!

When it does become a concern and I embark on implementing a more scalable solution, I’m happy to know I will have all of my comment data available: both in static rendered form and as raw data available via the Netlify API.

Automatic Google Analytics Outbound Link Tracking

hello.vectronic@gmail.com (vectronic) — Mon, 26 Nov 2018 00:00:00 +0000

Google Analytics tracking of internal links within your own website is super-simple. Tracking outbound links is slightly more involved. Google tells you how, but this requires remembering to modify each outbound link’s onclick event handler.

The Google answer involves installing an onclick event handler similar to the following for each outbound link:

<a href="http://www.example.com" onclick="trackOutboundLink('http://www.example.com'); return false;">Check out example.com</a>

When writing blog entries I didn’t want to have to remember this everytime. My other requirement was a nice indicator for the reader when links are external.

After suitable perusing of stackoverflow, and some trial and error, I submit to you the following code which handles a few hiccups I encountered:

local links might be specified as relative or absolute
links might be defined with relative protocol i.e. //www.example.com
Google Analytics might be blocked or somehow disabled
there might be an existing onclick handler defined
there might be an existing rel attribute (see further below for it’s use in styling)

So, onto the code:

Firstly, in the <head> element is the standard Google Analytics gtag.js setup:

    <script async src="https://www.googletagmanager.com/gtag/js?id=UA-121478710-1"></script>
    <script>
        window.dataLayer = window.dataLayer || [];
        function gtag(){dataLayer.push(arguments);}
        gtag('js', new Date());
        gtag('config', 'UA-121478710-1', { 'anonymize_ip': true });
    </script>

Nextly, at the end of the <body> tag is the automatic discovery, styling and onclick hijacking of the outbound links:

<script>
    // Get all links on the page
    Array.from(document.getElementsByTagName('a'))

        // Filter for outbound links
        .filter(link =>
            ((link.href.indexOf(location.host) > 8 || link.href.indexOf(location.host) === -1) &&
            (link.href.match(/^http:/i) || link.href.match(/^https:/i)))
            || link.href.match(/^mailto:/i)
        )

        // For each external link
        .forEach(externalLink => {

            // Set rel attribute as external to ensure styling applied
            if (externalLink.rel && externalLink.rel !== '') {
                externalLink.rel += " external";
            }
            else {
                externalLink.rel = "external";
            }

            // Save old onclick handler (if it exists) and install new one
            let oldOnClick = externalLink.onclick;
            externalLink.onclick = function(event) {

                // Test if Google Analytics loaded
                if (window.ga && ga.create) {
    
                    // Send tracking event
                    gtag('event', 'click', {
                        'event_category': 'outbound',
                        'event_label': externalLink.href,
                        'transport_type': 'beacon',
                        'event_callback': function() {
                            document.location = externalLink.href;
                        }
                    });
                }
                else {
                    document.location = externalLink.href;
                }
    
                // Invoke replaced onclick handler if it existed
                if (oldOnClick) {
                    return oldOnClick.call(this, event);
                }
                return false;
            }
        });
</script>

P.S. For the styling of external links something like the following CSS-fu should work:

a[*|rel~="external"]::after {
    display: inline-block;
    font-style: normal;
    font-variant: normal;
    text-rendering: auto;
    -webkit-font-smoothing: antialiased;
    font-size: x-small;
    font-family: "Font Awesome 5 Free";
    content: "\f35d";
    padding-left: 0.5em;
}

Multi-File Macro in FreeCAD

hello.vectronic@gmail.com (vectronic) — Mon, 12 Nov 2018 00:00:00 +0000

I’ve been developing a fairly complex macro for FreeCAD and wanted to split the code out into a module with separate files.

I couldn’t find instructions how to do this anywhere, but thankfully someone on the very helpful forum FreeCAD Forum gave me this answer.

So now I have the following in my macro folder:

Legify a sub-folder containing the Python module source files
legify-brick.FCMacro a macro file importing the module as follows:
```
from Legify import Brick
Brick.Dialog()
```

This structure can be seen in the macro repository on GitHub

Unicode in FreeCAD

hello.vectronic@gmail.com (vectronic) — Wed, 03 Oct 2018 00:00:00 +0000

I’ve been writing a Python macro for FreeCAD as a learning exercise on both subjects. I thought it would be nice to display the Circled Information Source unicode character as a tooltip icon in a GUI form. It looks like this: 🛈 (if your current viewing font supports it).

After attempting this for a couple of hours, I wanted to stop learning Python and head back to Java…

Here are the things to look out for when using Python 2.7:

As per PEP 263 a Python source file needs to start with:
```
# coding: UTF-8
```
Note: This isn’t required in Python 3 as UTF-8 is the default encoding as per PEP 3120.
UTF-8 string literals need to be prefixed with a u as follows:
```
u"My UTF-8 string 🛈"
```
Make sure to use a unicode character which has a code point less than the sys.maxunicode for your build of Python! This one was a real doozie to uncover. Here are some other devs dealing with the same issue

Note: Again things change in Python 3.3 as per PEP 393.

Within the FreeCAD 18.0 Python terminal:
```
Python 2.7.15 (default, Aug 22 2018, 16:41:11) 
[GCC 4.2.1 Compatible Apple LLVM 8.0.0 (clang-800.0.42.1)] on darwin
Type 'help', 'copyright', 'credits' or 'license' for more information.
>>> App.setActiveDocument("Unnamed")
>>> App.ActiveDocument=App.getDocument("Unnamed")
>>> Gui.ActiveDocument=Gui.getDocument("Unnamed")
>>> import sys
>>> print sys.maxunicode
65535
>>> 
```
Of course 🛈 has a decimal value of 128712 which is TOO BIG! So I’ve settled on using the Information Source character ℹ which has a decimal value of 8505.

Sample Content

hello.vectronic@gmail.com (vectronic) — Mon, 24 Sep 2018 00:00:00 +0000

Here is an image:

This is a caption

I ❤️ emoji!

Heading Level 1

Lorem ipsum dolor sit amet, consectetur adipiscing elit. Phasellus non neque odio.

Curabitur quis est ullamcorper, eleifend nisi a, rutrum eros. Donec laoreet quam massa, quis pellentesque odio ultrices nec. Nulla non mauris magna. Nullam ut enim ultrices, suscipit nunc in, suscipit tortor. Etiam lectus tortor, ultrices quis ligula nec, fermentum scelerisque velit. Sed accumsan, metus vel vestibulum rhoncus, nunc est sodales massa, facilisis sodales lacus turpis eu diam.

Heading Level 2

Lorem ipsum dolor sit amet, consectetur adipiscing elit. Phasellus non neque odio. Curabitur quis est ullamcorper, eleifend nisi a, rutrum eros. Donec laoreet quam massa, quis pellentesque odio ultrices nec. Nulla non mauris magna. Nullam ut enim ultrices, suscipit nunc in, suscipit tortor. Etiam lectus tortor, ultrices quis ligula nec, fermentum scelerisque velit. Sed accumsan, metus vel vestibulum rhoncus, nunc est sodales massa, facilisis sodales lacus turpis eu diam.

Heading Level 3

Here is another image:

Here is a list:

Lorem ipsum dolor sit amet, consectetur adipiscing elit.
Phasellus non neque odio. Curabitur quis est ullamcorper, eleifend nisi a, rutrum eros.

You can use the mark tag to highlight text.

~~This line of text is meant to be treated as deleted text.~~

This line of text will render as underlined

This line of text is meant to be treated as fine print.

This line rendered as bold text.

This line rendered as italicized text.

And here is some inline code

The following is a block quote:

Lorem ipsum dolor sit amet, consectetur adipiscing elit. Integer posuere erat a ante.

Someone famous in Source Title

The following is a lead text paragraph:

Vivamus sagittis lacus vel augue laoreet rutrum faucibus dolor auctor. Duis mollis, est non commodo luctus.

Here is a block of code:

front_tube_ribs_sketch.addExternal(self.doc.top_inside_datum_plane.Label, '')
constraints.append(Sketcher.Constraint("PointOnObject", segment_count + 1, 2, -3))

vectronic

First Real Project on the Pocket NC

Bun, WASM and Rust projects with GitHub Actions

Features

Repositories

“Application” Projects

“Simple Library” Projects

“Glue Library” Projects

“CI” Projects

A picture is worth a 1000 words… or maybe its just confusing…

Feedback

Minitel Terminal Connected via Asterisk

Further Details and Notes

Beginner Chips

Pocket NC Enclosure Reality

Pocket NC Enclosure Design

First Pocket NC chips!

Nostalgia - NetToaster

Nostalgia - Pogo Web Browser

Fusion 360 Baby Steps

Deno, WASM and Rust projects with GitHub Actions

Features

Repositories

“Application” Projects

“Simple Library” Projects

“Glue Library” Projects

“CI” Projects

A picture is worth a 1000 words… or maybe its just confusing…

Eclectic Mix of Workarounds

.github v1 branch

GitHub Pages to host WASM library releases

Reliance on Node and NPM

Git Update of Main Branch

Bleeding Edge

Outstanding Issues

Dynamic Import of WASM based Javascript Modules

Deno Compile support for dynamic imports

deno_bindgen updated to support the latest unstable Deno API

Automatic Rust API docs for projects using deno_bindgen

Deno signing and notarisation support

GitHub Actions support for Apple Silicon

Feedback

Legify 0.4.0

3D Printed Brick Assemblies

Legify 0.3.0

New FreeCAD Assembly Render and Animation

Recent FreeCAD Macro Lessons

Additive Pipe With Path and Profile Sketches

Sketch Placement and Rotation

Body.Tip Gotcha

A Successfully Rendered FreeCAD Assembly

Building FreeCAD on macOS Big Sur

Install 3DConnexion drivers

Install miniconda

Prepare Conda environment

Install FreeCAD

See if it works

Install Xcode command line tools

Install Extension Manager workbench

Install cycles standalone

FreeCAD configuration

Install Assembly4 using Extension Manager Workbench

Install Render Workbench using Extension Manager Workbench

Configure Render Workbench to use Cycles

Test Part Design model render

Test Assembly4 model render

Migrate to Deno?

Legify 0.2.2

FFmpeg now supports ICC Profiles in MP4

Changes

Usage

Legify 0.2.0

Measurement of Lego Brick Dimensions

Timecodes in Excel without Macros

Building FreeCAD Assembly3 on macOS using Conda

Install 3DConnexion Drivers

Install miniconda

Install MacOSX10.9.sdk

Set SDK location for Conda

Link to SDK for Circle CI based support scripts

Automatic Rust API docs for projects using `deno_bindgen`