Category: goatee-stroking musing, or something

Georg Nees (1926–2016) was a pioneer of generative art. His piece “Schotter” (gravel) from 1968 displayed a rectangular array of squares with the position of each square becoming more random as the piece progressed.

The BASIC code for this video is based on Processing code by Jim Plaxco, http://www.artsnova.com/

The Tektronix 4010 display simulator is by Rene Richarz, https://github.com/rricharz/Tek4010

The BASIC interpreter with Tektronix graphics support is Matrix Brandy BASIC maintained by Michael McConnell, https://github.com/stardot/MatrixBrandy

(Higher-quality video at Georg Nees’ “Schotter”, reproduced on a simulated Tek4010 display at YouTube.)

  100 REM Georg Nees "Schotter" reproduction - scruss, 2019-11
  110 REM based on Processing 3 code by Jim Plaxco, www.artsnova.com
  120 :
  130 scrn_wd% = 2048: REM fixed screen size, unlike Processing
  140 scrn_ht% = 1560
  150 columns% = 12
  160 rows% = 22
  170 sqsize% = FN_min(scrn_wd% / (columns% + 4), scrn_ht% / (rows% + 4))
  180 padding% = 2 * sqsize%
  190 randstep = 0.22
  200 randsum = 0.0
  210 randval = 0.0
  220 dampen = 0.45
  230 :
  240 SYS "Brandy_TekEnabled", 1
  250 A$=GET$: REM PLOT 4, 0, 0: PLOT 5, 0, 0
  260 FOR y% = 1 TO rows%
  270   randsum = randsum + (y% * randstep)
  280   FOR x% = 1 TO columns%
  290     randval = RND(1) * (2 * randsum) - randsum
  300     PROC_square((scrn_wd% / 2) - (sqsize% * columns% / 2) + (x% * sqsize%) - (sqsize% / 2) + INT(randval * dampen), scrn_ht% - (padding% + (y% * sqsize%) - (sqsize% / 2) + INT(randval * dampen)), sqsize%, randval)
  310   NEXT x%
  320 NEXT y%
  330 PLOT 4, 0, 0: PLOT 5, 0, 0
  340 END
  350 :
  360 DEF PROC_square(cx%, cy%, side, angle)
  370 LOCAL r, i%, pm%
  380 pm% = 4: REM plot mode - move = 4, draw = 5
  390 r = (side / 2) / (SQR(2) / 2)
  400 FOR i% = 0 TO 4
  410   PLOT pm%, cx% + r * COS(RAD(angle + i% * 90 + 45)), cy% + r * SIN(RAD(angle + i% * 90 + 45))
  420   pm% = 5
  430 NEXT i%
  440 ENDPROC
  450 :
  460 DEF FN_min(a%, b%) IF a% < b% THEN =a% ELSE =b%

A little slice of UK consumer history: The Argos Book of Dreams, scanned Argos catalogues from 1974 to present. (Via b3ta)

It seems that all (?) of these are also up at the Internet Archive. They’re a little harder to find, and some don’t have previews. A decent search for one uploader’s history is “retromash”, though “argos catalogue” finds more. The Book of Dreams site seems only to have autumn/winter catalogues, while the Archive has the spring/summer ones too.

After reading I didn’t know lithophanes were so simple. They were hiding in Cura all along. : 3Dprinting, I thought I’d give OpenSCAD a shot at generating a lithophane image. It did not badly at all, considering this was my first try.

This isn’t a fast process and generates huge STL files, but it’s fairly simple. Here’s how I did it:

1. Download your image. I used this 479 × 599 pixel preview.
2. Convert your image to PNG, preferably grey scale
3. Run it through the OpenSCAD script below, changing the parameters according to the instructions
4. Render it in OpenSCAD (slow)
5. 3D print the resultant STL in 0.05 mm layers (very slow)

//  somewhat rough OpenSCAD lithophane - scruss, 2019-10
 infile  = "479px-Muhammad_Ali_NYWTS.png";    // input image, PNG greyscale best
 x_px    = 479;  // input image width,  pixels
 y_px    = 599;  // input image height, pixels
 z_min   = 0.8;  // minimum output thickness, mm
 z_max   = 3;    // maximum output thickness, mm
 y_size  = 50;   // output image height, mm
 // don't need to modify anything below here
 translate([0, 0, z_max])scale([y_size / y_px, y_size / y_px, (z_max - z_min)/100])surface(file = infile, invert = true);
 cube([x_px * y_size / y_px, y_size, z_min]);

I used Makerbot warm white PLA. It looks decent at viewing distance, but close up it’s a bit stringy.

There are better packages, but OpenSCAD does this better than I expected.

PLOTPOURRI is an old BASIC graphics demo for the Apple II. It plots 3D functions immensely slowly. It was noticed on the stardot forum, and a BBC BASIC version was requested.

My conversion lives here: scruss/plotpourri_bbc.bas and runs in the browser here.

The greatest common divisor (gcd) of two natural numbers is the largest number that evenly divides both. For instance gcd(8, 12) is 4. There are many clever and efficient ways to calculate the gcd of two numbers on a Linux machine. The method presented here is not among them.

#!/bin/bash
gcd(){ comm -12 --nocheck-order <(factor $1|sed 's/^[^ ]*/1/;s/ /\n/g') <(factor $2|sed 's/^[^ ]*/1/;s/ /\n/g')|tr '\n' \*|sed 's/.$/\n/'|bc;}
gcd $1 $2 

(Contrived) example:

gcd.sh 24691357802469135780246913578 61728394506172839450617283945
12345678901234567890123456789

Which breaks down as:

Multiply the factors common to both:

3 × 3 × 3 × 7 × 13 × 31 × 37 × 211 × 241 × 2161 × 3607 × 3803 × 2906161 = 12345678901234567890123456789

I’m sure someone else has used the output of factor and comm in this way before. The hard part was getting coprime numbers to output 1.

Simple things like fasteners don’t seem to be invented. It’s almost as if they’ve always been around. Like T-nuts — those hammer-in furniture nuts that also find use as 3D printable tripod mounts — someone invented those?

Sure enough, it seems that local company Sigma Tool & Machine have a lot to do with T-nut development. They’re now on Nantucket Blvd just north of me, and they used to be at 96 Crockford Blvd very close by.

This may not look much, but it’s a test build of Vik Olliver’s Quirkey USB chord keyboard. I didn’t quite build it to Vik’s specs, which are here:

• code: VikOlliver/Microwriter: A reboot of the 80’s Microwriter accessible chord keyboard done using an Arduino
• case: Quirkey Chord Keyboard Shell

The Microwriter was a late 1970s/early 1980s gadget that was essentially a portable word processor. Unusually, its keyboard was a single-hand 6 key layout — the thumb did double duty — that was operated by chording multiple keys at the same time. Later on in the Microwriter’s life it evolved into the Quinkey, a chording adaptive keyboard for computers of the time.

Technology has moved on a bit, and the ability to wire up a cheap USB-capable microcontroller and 3d print your own case is here. I used an Arduino Micro on a breadboard and six Omron momentary buttons.

I didn’t quite wire it the way that Vik intended:

The buttons are wired like this:

Pin      Button
=======  =======
 D8       Control
 D7       Thumb
 D6       Index
 D5       Middle
 D4       Ring
 D3       Pinkie

This requires changing line 22 of Vik’s code from:

const int keyPorts[] = {8, 7, 6, 5, 4, 9};

to

const int keyPorts[] = {8, 3, 4, 5, 6, 7};

While there are great tutorials on “microwriting” in the original manuals on Bill Buxton’s site, here are the basic alphabetic set derived from Vik’s code:

Thumb
|Index
||Middle
|||Ring
||||Pinkie
●○○○○ : Space
○●○○○ : e
●●○○○ : i
○○●○○ : o
●○●○○ : c
○●●○○ : a
●●●○○ : d
○○○●○ : s
●○○●○ : k
○●○●○ : t
●●○●○ : r
○○●●○ : n
●○●●○ : y
○●●●○ : .
●●●●○ : f
○○○○● : u
●○○○● : h
○●○○● : v
●●○○● : l
○○●○● : q
●○●○● : z
○●●○● : -
●●●○● : '
○○○●● : g
●○○●● : j
○●○●● : ,
●●○●● : w
○○●●● : b
●○●●● : x
○●●●● : m
●●●●● : p

The astute reader may note that these are binary values (low bit to high) of the character positions in Vik’s alphaTable variable. And yes, that’s supposed to be preformatted text.

Happy microwriting!

Buttons, Tactile switches, Momentaries, Clickies, SPST-NO; call ’em what you will, but my world seems to be full of them right now. Wiring them or breadboarding them may not be as simple as they look.

Whether they are the tiny 6 mm ones or the less-easily-lost 12 mm ones, both types typically have four pins or legs, two on the top and two on the bottom. If your appear to have the legs on the sides, flip ’em 90°: they won’t fit in breadboard sockets the wrong way.

The pins on the left and right side are common, so connecting top left to bottom left won’t ever change state if you press the button. So use either the pins both on the same side or those diagonally opposed if you want the switch to work.

You can use these buttons on a common breadboard rail. You must remember to have only one button pin connecting to the rail; lift the other pin so it won’t connect. You can then use just one wire connected diagonally across the the common rail pin and you’ve got a working button. This is especially useful when using a microcontroller with built-in pull up resistors (that’s most of them these days).

If you connect both pins to a common rail, you’ve just made a SPST-AO (single pole, single throw – always open) switch. Those aren’t much use at all.

This was a real graph from a project I worked on. I’m not at liberty to tell you what it’s from, but it had a use at the time. It’s not just random scribbles