Positron BASIC Community

Les. AWOL. hope its a holiday

He posted on Monday!

https://protoncompiler.com/index.php?msg=25005

Last active:30-09-2026, 10:35:53

John

Sorry I have not been on the forum as much lately, but I have been so busy with code Jon created and Dyanko created, that time ran away. The code is a working emulator for the Atari POKEY chip, and it works wonderfully, with the code that Jon had AI create, with his coding talents to tailor it, and the same for Dyanko, using different AI apps, and the results are incredible. I have yet to fully get into the AY-3-8910 emulator code, but I will once I get the time. It brings back so many memories of the sound add-on I made that plugged into the back of my ZX81 using the AY chip, later adapted for the ZX Spectrum, and the sounds of my beautiful Atari 800 with the POKEY player.

Truly amazing is the players Jon wrote for teh emulators that actually run sound, adapted, sound files available online, and I will be creating projects pages for them on my Google web site.

But it also shows that we programmers are now a semi-extinct species. :-) In a few years, there will be no need for designers, code writers etc... Even artists and general writers are now close to becoming extinct, because AI is so good at predicting what the sheep like. :-)

I am also learning OpenSCAD for 3D printing, and it is very good. It is a language based 3D CAD, and is very similar to C, instead of the dreadfully expensive fusion 360, and the, generally, dreadful FreeCAD.

It is excellent for creating technical 3D items.

For example, a 3D printed replica of a Radionic X40 electronics set Transistor base:

//
// Radionic X40 Re-creation
// Right-Angle Triangular Base with Underside Cutout
//
// Pitch defines the center-to-center straight distance between the terminal centers
//
Pitch = 18.90;
//
// Triangle Vector Coordinates
// These calculate the precise X and Y points for your three mechanical terminal positions
// By subtracting/adding half the Pitch value, the 90-degree corner aligns beautifully
//
Hole_1 = [-Pitch / 2, -Pitch / 2];      // Bottom-Left Coordinate Vector: The core 90-degree corner
Hole_2 = [ Pitch / 2, -Pitch / 2];      // Bottom-Right Coordinate Vector: Extends horizontally out along +X
Hole_4 = [-Pitch / 2,  Pitch / 2];      // Top-Left Coordinate Vector: Extends vertically up along +Y
//
// Adjustable Base Structural Parameters
//
Base_Height         = 6.2;              // Total physical Z-axis thickness of the vintage plastic base (mm)
Outer_Padding       = 4.6;              // Material border width padding out radially past the hole centers (mm)
Outer_Corner_Rad    = 3.0;              // Radius used by OpenSCAD's offset engine to round exterior sharp vertices (mm)
//
// Manipulatable Central Triangle Recess Parameters (Adjusted for Right Angle Triangle)
//
Recess_Width        = 9.6;              // Core baseline width footprint of the triangular pocket shape (mm)
Recess_Height       = 9.8;              // Core vertical height footprint of the triangular pocket shape (mm)
recess_corner_rad   = 3.0;              // Fillet rounding radius applied to smooth internal corners of the pocket (mm)
recess_depth        = 1.0;              // Precision depth cutting downward into the top surface of the block (mm)
bottom_recess_depth = 3.5;              // Depth cutting upward into the bottom face floor via the cutout (mm)
//
// Reversed Underside Settings
// Defines how thick the circular plastic bosses remain to structurally protect screw thread mounts
//
Bottom_Boss_Padding = 3.5;              // Radial plastic thickness surrounding the edge of each through-hole (mm)
//
// Mechanical Hardware Settings
//
Terminal_Hole_Diameter = 4.9;           // Hole size for the threaded insert (mm)
$fn = 60;                               // Fragment Number: Rendering smoothness (60 segments make a full circle)

//--------------------------------------------------------------------------------------------
// Generates the main, solid, 3D triangular block
//
module Outer_Body()
{
    //
    // Linear_Extrude: Pulls the flat 2D shape upward into a solid 3D form
    // height = Base_Height: Extrudes to 6.6mm.
    // center = true: Centers it on the Z-axis, splitting it equally from Z = -3.3mm to Z = +3.3mm
    //
    linear_extrude(height = Base_Height, center = true)
    {
        //
        // offset: Inflates the 2D path geometry outward and completely rounds off the sharp corners
        //
        offset(r = Outer_Padding)
        {
            //
            // polygon: Connects your three 2D grid coordinates to build the root triangular surface
            //
            polygon(points = [Hole_1, Hole_2, Hole_4]);
        }
    }
}

//--------------------------------------------------------------------------------------------
// Builds the 3D triangular cutting tool designed to mill out the upper face window pocket
// pDepth is the depth of teh recess (in mm)
//
module Create_Top_Recess(pDepth)
{
    //
    // Local calibration constants to dynamically scale and tune internal wall orientation
    //
    Width_Div = 0.98;
    Height_Div = 1.04;
    //
    // Extrudes the 2D pocket profile to the exact depth passed in through the 'pDepth' argument
    //
    linear_extrude(height = pDepth, center = true)
    {
        //
        // Smooths out the sharp inner right-angle corners inside the recess footprint
        //
        offset(r = recess_corner_rad)
        {
            //
            // polygon: Computes a matching right-angle triangle tailored to offset neatly within the outer body
            //
            polygon(points = [
                             [(-Recess_Width / Width_Div) + 0.2, (-Recess_Height / Height_Div) - 0.2],  // Bottom Left point
                             [( Recess_Width / Width_Div), (-Recess_Height / Height_Div) - 0.1],        // Bottom Right point
                             [(-Recess_Width / Width_Div) + 0.2,  (Recess_Height / Height_Div) + 0.2]   // Top Left point
                             ]);
        }
    }
}

//--------------------------------------------------------------------------------------------
// An alternative module to create a simple bottom triangular pocket matching the top footprint
// pDepth is the depth of the curout (in mm)
//
module Create_Bottom_Recess(pDepth)
{
    Width_Div = 0.98;
    Height_Div = 1.04;
    linear_extrude(height = pDepth, center = true)
    {
        offset(r = recess_corner_rad)
        {
            polygon(points = [
                             [(-Recess_Width / Width_Div) + 0.2, (-Recess_Height / Height_Div) - 0.2],  // Bottom Left point
                             [( Recess_Width / Width_Div), (-Recess_Height / Height_Div) - 0.1],        // Bottom Right point
                             [(-Recess_Width / Width_Div) + 0.2,  (Recess_Height / Height_Div) + 0.2]   // Top Left point
                             ]);
        }
    }
}

//--------------------------------------------------------------------------------------------
// Generates the reversed pocket cutting tool. It builds a wide block but subtracts loops
// around the terminal points, leaving isolated structural columns (bosses) around the screw shafts
// pDepth is the depth of the curout (in mm)
//
module Create_Bottom_Cutout(pDepth)
{
    //
    // Extrudes the inverted 2D masking profile into a 3D carving tool matching 'pDepth'
    //
    linear_extrude(height = pDepth, center = true)
    {
        //
        // difference() [2D]: Takes the main shape and subtracts the inner circles from it
        //
        difference()
        {
            //
            // Creates an expanded triangle boundary (padded by half the outer padding value)
            // This guarantees the cutting block completely covers and breaches the outside edges cleanly
            //
            offset(r = Outer_Padding / 2)
            {
                polygon(points = [Hole_1, Hole_2, Hole_4]);
            }
            //
            // circle: Defines 2D circular masks positioned precisely at your terminal points
            // Radius formula: (Hole Diameter / 2) + Padding space = Total solid radius protected from being cut
            //
            translate(Hole_1)
                circle(r = (Terminal_Hole_Diameter / 2) + Bottom_Boss_Padding);
            translate(Hole_2)
                circle(r = (Terminal_Hole_Diameter / 2) + Bottom_Boss_Padding);
            translate(Hole_4)
                circle(r = (Terminal_Hole_Diameter / 2) + Bottom_Boss_Padding);
        }
    }
}

//--------------------------------------------------------------------------------------------
// The master assembly pipeline. Uses CSG (Constructive Solid Geometry) to cut shapes from the main body
//
module Radionic_Triangular_Component_Block()
{
    //
    // difference() [3D]: Retains the first sub-item, and carves out every single item nested underneath it
    //
    difference()
    {
        //
        // Subtraction Base: The main solid plastic block
        //
        Outer_Body();
        //
        // The Top Face Pocket
        //
        // translate Z math: Moves the tool directly up to flush with the upper surface
        // Calculation: (6.6 / 2) = 3.3mm (Top edge), minus (1.0 / 2) = 0.5mm aligns centers perfectly
        // +0.01: Adds a tiny overlap to guarantee the face skin is pierced cleanly, avoiding rendering glitches
        //
        translate([0, 0, (Base_Height / 2) - (recess_depth / 2) + 0.01])
            Create_Top_Recess(recess_depth);
        //
        // Optional Standard Bottom Face Pocket
        //
        // This operation is bypassed by your double-slashes (//). It is left as a legacy option
        // translate([0, 0, -(Base_Height / 2) + (bottom_recess_depth / 2) - 0.01])
        //     Create_Bottom_Recess(bottom_recess_depth);
        //
        // The Inverted Bottom Face Cutout
        //
        // translate Z math: Multiplies by -1 to drop the tool flush against the bottom surface
        // -0.01: Forces the cutting shape slightly past the floor skin for a clean, non-manifold breach
        translate([0, 0, -(Base_Height / 2) + (bottom_recess_depth / 2) - 0.01])
            Create_Bottom_Cutout(bottom_recess_depth);
        //
        //
        // Three Through-Holes for M3 Terminal Hardware
        //
        // cylinder: Creates 3D round holes
        // h = Base_Height + 2: Over-extends the length of the cylinder tool so it safely exits both faces
        // center = true: Aligns the vertical center of the drill tool with the center of the base block
        // Note: Using indexing [0] and [1] to cleanly unpack 2D vectors into 3D translation spaces
        //
        // Hole 1: Drills out the main 90-degree corner terminal channel
        //
        translate([Hole_1[0], Hole_1[1], 0])
            cylinder(d = Terminal_Hole_Diameter, h = Base_Height + 2, center = true);
        //
        // Hole 2: Drills out the right terminal channel
        //
        translate([Hole_2[0], Hole_2[1], 0])
            cylinder(d = Terminal_Hole_Diameter, h = Base_Height + 2, center = true);
        //
        // Hole 3: Drills out the upper left terminal channel
        //
        translate([Hole_4[0], Hole_4[1], 0])
            cylinder(d = Terminal_Hole_Diameter, h = Base_Height + 2, center = true);
    }
}
//--------------------------------------------------------------------------------------------
// The main code starts here
//
    Radionic_Triangular_Component();


With some help for the 'free' Google AI, to start me off on it.

I have the 2 terminal base complete, for the 2 wire components, and the 3 terminal base for the transistors, and the ferrite rod coil formers, but I am having a bit of a problem with the ferrite rod holder, but I am getting there with it. Then I will create a base for a microcontroller, so the 1970s Radionic kit I am re-creating will have the ability to run 21st century circuits.

Best regards
Les

Hi Les

Glad to hear you are ok.  I use the free version of Fusion360 and it covers my Hobby needs.  If you want anything printed, I have a resin and filament printer.

Thanks Jon.

I did have the hobby version of Fusion360 installed on my machine, but it constantly wanted signing in when it was first used, and everything went to its cloud and not the computer, so I got totally fed up with it.

It used to be such a good program, until it was bought as an "asset" by a corporate.

I have a filament 3D printer, and thanks to Bob giving me an older 3D printer, and Tim giving me his Elegoo printer a couple of years ago, it gave me the 'bug', so I now use a 'Bambu A1 Mini' printer, and it is excellent, and that is 'putting it lightly'. It is the 3D printer equivalent of 'Plug and Play', and the quality of the prints is something I did not know they could do.

I do fancy a resin printer, so I will have to persuade my Rachel to left me save up for one. I've seen some models from them, and they are incredible, and it is impossible to see that they were 3D printed.

Roll on the day the fibre LASER 3D printers come down to an affordable price, so metals can also be printed. Then complete PCBs can be made all in one go. Through holed as well.

Best regards
Les

here is a microcontroller base for you.
//
// Radionic X40 21st-Century Extension: 4-Terminal Microcontroller Base
// Spaced perfectly to align onto the authentic 18.90mm grid layout
//
Pitch = 18.90;
$fn = 60;

// 4-Terminal Grid Mapping (Forms a perfect square to straddle the grid holes)
Hole_1 = [-Pitch / 2, -Pitch / 2]; // Bottom-Left
Hole_2 = [ Pitch / 2, -Pitch / 2]; // Bottom-Right
Hole_3 = [ Pitch / 2,  Pitch / 2]; // Top-Right
Hole_4 = [-Pitch / 2,  Pitch / 2]; // Top-Left

// Structural Profiles
Base_Height         = 6.2;   // Native X40 thickness
Outer_Padding       = 4.6;  
Outer_Corner_Rad    = 3.0;  
Terminal_Hole_Diam  = 4.9;  
Bottom_Boss_Padding = 3.5;
bottom_recess_depth = 3.5;

// Microcontroller Pocket (Sized for a standard development board variant)
MCU_Width           = 18.5;  // Adjust to fit target MCU width precisely
MCU_Length          = 45.0;  // Adjust to fit target MCU length precisely
MCU_Pocket_Depth    = 2.5;   // Deep enough to sink the PCB flat

module Rectangular_MCU_Body()
{
    linear_extrude(height = Base_Height, center = true)
    {
        offset(r = Outer_Padding - Outer_Corner_Rad)
        {
            offset(r = Outer_Corner_Rad)
            {
                // Form a stable rectangular footprint over the 4 grid corners
                polygon(points = [Hole_1, Hole_2, Hole_3, Hole_4]);
            }
        }
    }
}

module MCU_Top_Pocket()
{
    // Generates a drop-in slot for the microcontroller board
    translate([0, 0, (Base_Height / 2) - (MCU_Pocket_Depth / 2) + 0.01])
        cube([MCU_Width, MCU_Length, MCU_Pocket_Depth + 0.02], center = true);
}

module Master_MCU_Block()
{
    difference()
    {
        Rectangular_MCU_Body();
        MCU_Top_Pocket();
       
        // Drill standard vintage mechanical through-holes at all 4 grid vectors
        for (pos = [Hole_1, Hole_2, Hole_3, Hole_4]) {
            translate([pos[0], pos[1], 0])
                cylinder(d = Terminal_Hole_Diam, h = Base_Height + 2, center = true);
        }
    }
}

Master_MCU_Block();



Ferrite


//
// Radionic X40 Re-creation - Ferrite Rod Holder Base
// Features elevated, flexible snap-fit C-clips to protect brittle rods
//
Pitch = 18.90;
$fn = 60;

// 2-Terminal Positions (Spaced along the X-axis grid line)
Hole_1 = [-Pitch / 2, 0];
Hole_2 = [ Pitch / 2, 0];

// Base Structural Parameters
Base_Height         = 6.2;              // Standard vintage base thickness
Outer_Padding       = 4.6;             
Outer_Corner_Rad    = 3.0;             
Terminal_Hole_Diam  = 4.9;             
Bottom_Boss_Padding = 3.5;
bottom_recess_depth = 3.5;

//--- Ferrite Rod Clamp Parameters ---
Rod_Diameter        = 9.5;   // Standard AM radio ferrite rod diameter (mm)
Clamp_Width         = 6.0;   // Physical thickness of each vertical clamp ring
Clamp_Height_Offset = 10.0;  // Height of rod center above the base plate
Clamp_Gap           = 6.5;   // Top opening width allowing the rod to snap in
Holder_Spacing      = 22.0;  // Distance separating the two clips along the Y-axis

module Base_Footprint()
{
    linear_extrude(height = Base_Height, center = true)
    {
        offset(r = Outer_Padding - Outer_Corner_Rad)
        {
            offset(r = Outer_Corner_Rad)
            {
                // Generates an elongated oval base tracking the 2 terminal poles
                polygon(points = [Hole_1, Hole_2, [Pitch/2, 0.1], [-Pitch/2, 0.1]]);
            }
        }
    }
}

module Single_C_Clip()
{
    // Generates an elevated circular clamp loop with a top entry gap
    difference()
    {
        // Main outer support column loop
        translate([0, 0, Clamp_Height_Offset])
            rotate([90, 0, 0])
                cylinder(d = Rod_Diameter + 4.0, h = Clamp_Width, center = true);
               
        // Inner core cutout for the ferrite rod barrel
        translate([0, 0, Clamp_Height_Offset])
            rotate([90, 0, 0])
                cylinder(d = Rod_Diameter, h = Clamp_Width + 0.2, center = true);
               
        // The Top Opening Gap: Allows the plastic arms to flex outwards
        translate([0, 0, Clamp_Height_Offset + (Rod_Diameter/2)])
            cube([Clamp_Gap, Clamp_Width + 0.4, Rod_Diameter], center = true);
    }
   
    // Solid vertical pillar connecting the elevated loop down to the base unit
    difference()
    {
        translate([0, 0, Clamp_Height_Offset / 2])
            cube([Rod_Diameter + 4.0, Clamp_Width, Clamp_Height_Offset], center = true);
       
        // Internal clean-out to keep the curved contour flush
        translate([0, 0, Clamp_Height_Offset])
            rotate([90, 0, 0])
                cylinder(d = Rod_Diameter, h = Clamp_Width + 0.2, center = true);
    }
}

module Master_Ferrite_Holder()
{
    difference()
    {
        // 1. Combine Base and the Two Elevated Clamps
        union()
        {
            Base_Footprint();
           
            // Front Clip
            translate([0,  Holder_Spacing / 2, 0]) Single_C_Clip();
            // Rear Clip
            translate([0, -Holder_Spacing / 2, 0]) Single_C_Clip();
        }
       
        // 2. Drill the standard mechanical terminal mounting shafts
        translate([Hole_1[0], Hole_1[1], 0])
            cylinder(d = Terminal_Hole_Diam, h = Base_Height + 2, center = true);
           
        translate([Hole_2[0], Hole_2[1], 0])
            cylinder(d = Terminal_Hole_Diam, h = Base_Height + 2, center = true);
           
        // 3. Clear space out from the bottom floor (Optional material saver)
        translate([0, 0, -(Base_Height / 2) + (bottom_recess_depth / 2) - 0.01])
            linear_extrude(height = bottom_recess_depth + 0.02, center = true)
                difference() {
                    offset(r = Outer_Padding / 2) polygon(points = [Hole_1, Hole_2]);
                    translate(Hole_1) circle(r = (Terminal_Hole_Diam / 2) + Bottom_Boss_Padding);
                    translate(Hole_2) circle(r = (Terminal_Hole_Diam / 2) + Bottom_Boss_Padding);
                }
    }
}

// Render the completed layout assembler
Master_Ferrite_Holder();



Home resin printers are ok but limited for anything structural or heat-related; they are also messy and are stinky.  If I need it to be super good, it gets sent out to the pros with the million-pound HP laser machines.  Parts are also cheap now, with simple blocks like those costing less than a pound.

PETG is a pretty good all-rounder for the A1; it has great thermal properties, and all you need is a cheap single-drum dryer to keep moisture levels low.

Nearly Jon, but not quite. :-)

The Radionic X40 Ferrite holder is a curved item, that uses a rubber band over it.

Also, the microcontroller base will need to be contoured to fit the existing PCB.

The 4 terminal bases are for the transformers.

But it shows that SCAD is an excellent method of creating 3D models.

Very best regards
Les

Yeah, it is.  I've used it but have moved on to Fusion again. The naggy screens are not there, but you do need to cloud log in, but you can save locally.  It's still a faff, but it does produce great products.

I recently created a tight-fitting box for the Waveshare RPi module, adding a LiPo battery and USB/Buttons, all in Fusion and printed at home on a P2s.  Pics are for a 2.8" touch-screen fishing multi-app toy I did to keep track of the nets and calculate the pounds and ounces when doing the weigh-in at competitions.  It calculates and stores the weights in memory, can recall them for reference, and can download them if needed.  Stop anyone saying it's wrong!!  the lipo also recharges via USB and lasts about 8 months on a charge and used a couple times a week.