Introduction

The user interface for the Buildbotics CNC Controller is really nice. It's easy to use and flexible. But, every user and application is different and the interface may not be optimal for every case.

Maybe you want to run it from your smart phone, but find the web interface to be too busy to all fit on a smart phone. Maybe you want more macro buttons. Maybe you want to limit the things a user can do. You get the picture, there always things that could be done differently or more efficiently for each unique user and application.

That's where the Buildbotics Applications Programming Interface (API) comes in. We recently published a full description of the API and quietly announced it. This describes how to use it.

Also, check out my blog post titled Creating a CNC Jogging App for an Android Phone to see a real life example.

API Overview

Applications that use the API will connect to the Buildbotics Controller via the hardwired Ethernet port or through the WiFi interface.

The API exposes WebSocket and HttpRequest interfaces.

The WebSocket interface initially receives many state variables from the controller when the websocket is first opened and then subsequently receives those variables again whenever they change.

The WebSocket interface can also be used to run Manual Data Input (MDI) commands.

The HttpRequest interface is used to send specific commands and send or receive information or files.

WebSocket Interface

Most applications need to monitor the state of the machine. That single interface will send back the state variables and their values and then send each variable again if it changes.

Here's some javascript code that will open a WebSocket with my Buildbotics CNC Controller and then handle the state messages as they arrive.

is_object(o) {return o !== null && typeof o == 'object'},

update_state(state, update) {
  for (const [key, value] of Object.entries(update))
    if (is_object(value) && is_object(state[key]))
      update_state(state[key], value)
    else state[key] = value
}

let state
let ws = new WebSocket('ws://192.168.12.243/websocket')

ws.onmessage(event) {
  let msg = JSON.parse(event.data)
  if (state == undefined) state = msg  // First message
  else update_state(state, msg)        // Update messages
}

The 'let state' line initializes a variable called state, which will ultimately maintain a list of all variables and their current value.

This piece of code opens a WebSocket with the Buildbotics Controller and puts it in 'ws'. The argument to WebSocket is a Uniform Resource Locator (URL). Replace '192.168.12.243' with the IP address for your controller.

Then, whenever a message arrives, the code in ws.onmessage is called with the message contained in the 'event' argument. 'msg' is then gleaned from the event. For the first message, the variable state is set to msg. Subsequent messages are passed to update_state.

update_state then finds all the variables and their values in 'msg' and updates state.

Now that you have the variables, you can monitor them and take whatever action desired based on their valued. For instance, you could add a line to update_state that raises an alert if the machine is estopped.

update_state(state, update) {
  for (const [key, value] of Object.entries(update))
    if (is_object(value) && is_object(state[key]))
      update_state(state[key], value)
    else state[key] = value
    if (key === 'es' && value == 0) alert('Machine Estopped!')
}

The variables and their definitions are documented in bbctrl-vars-schema.

You can also send messages to the Buildbotics Controller via this same WebSocket. Any command that can be sent through the MDI interface on the Buildbotics Control page can also be sent through this WebSocket interface. For instance, if I want motor 0 to set to homed, I could use a command like this.

ws.send('0homed=1')

HttpRequest Interface

The HttpRequest interface is used for sending and receiving files, loading and setting the configuration, telling the machine to run, stop, start, pause, jog, reboot, estop, and lots of other things. The Applications Programming Interface (API) document provides a detailed list of the commands that the Buildbotics Controller accepts.

These commands use 'GET', 'PUT', and 'DEL' HttpRequests as described in the API. The API also specifies the URL for each command. The API provides nice examples of how to send and receive each command in various technologies such as unix Shell, javascript, java, python and others.

In javascript, it's best to use fetch commands.

Here's an example of how to read the hostname in javascript.

try {
  const response = await fetch('http://192.168.12.243/api/hostname);
  if (response.ok) {
    const data = await response.json();
    console.log('got response', data);
   }
} catch (e) {
  console.log('error:', e);
}

Note that the javascript fetch command automatically assumes a 'GET' request if the request method is not specified.

Here's an example of using the controller to start jogging on the X axis at full speed.

try {
  const response = await fetch('http://192.168.12.243/api/jog', {
                        method: 'PUT',
                        body: JSON.stringify({'X': 1,'ts':Date.now()}),
                        headers: {
                        'Content-Type' : 'application/json',
                    },
  });
  if (response.ok) {
    return;
  }
} catch (e) {
}

Here's an example of how to write a file to the Buildbotics Controller.

async writeRemoteFile(data, path, fileName) {    
  let fd = new FormData();
  let blob = new Blob([data], {type: 'text/plain'});
  let file = new File([blob], fileName);
  fd.append('file', file);
  let url = path + fileName;
  await fetch(url,{method :'PUT', body: fd})
}

writeRemoteFile('this is some file content',
                'http://192.168.12.243/api/fs/Home/',
                'newfile.txt')

Conclusion

The Buildbotics API can be used by developers to do pretty much anything you want. Remember, freedom comes with responsibility. It's certainly possible to mess things up on your Buildbotics CNC Controller royally using this interface. I recommend making a backup of your MicroSD card before you start.

If you are planning to do applications development on the Buildbotics CNC Controller, please consider joining our Applications Development forum.

Introduction

This is a step-by-step procedure for creating an application for jogging your Buildbotics CNC with an Android Phone. My development system is a desktop computer running debian linux and my phone is a Pixel 8. This procedure utilizes the React Native applications development framework. Other combinations of development systems and android phones will be very similar.

Besides the phone and development system, all you'll need is a USB cable to connect your phone to your development computer.

Note - The development process for IOS phones should be similar, but I haven't tried that.

Check out my blog posting titled Introduction to the Buildbotics CNC Controller API to learn about the Buildbotics API.

Step 1 - Set up your computer for developing react-native applications.

1. Open a terminal in the folder where you want the root folder for the app to reside.
2. Ensure that node.js and npm are installed on your system

sudo apt update
sudo apt install node.js
sudo apt install npm

3. Tell npm to put commands in ~/.global/bin. This only needs to be done once for your system. Then add the .npm-global/bin to your path.

npm config set prefix '~/.npm-global'
export PATH=$PATH:~/.npm-global/bin

Then, add the following line to your .bashrc file.

export PATH=$PATH:~/.npm-global/bin

4. Download and install the command-line-tools from Android Developer Studio. In my case, I downloaded the file called android-studio-2024.2.2.15-linux.tar.gz. Then, extract the files to the Android/Sdk directory under your home directory. Then add these lines to your .bashrc file.

    export ANDROID_HOME=$HOME/Android/Sdk
    export PATH=$PATH:$ANDROID_HOME/tools:$ANDROID_HOME/tools/bin:$ANDROID_HOME/platform-tools

5. Then reload your .bashrc file to ensure your current paths are correct.

source ~/.bashrc

Step 2 - Prepare your phone

Enable developer options on your phone. In my case, I have a 'pixel 8' phone and the developer options can be enabled by going to Settings->About. Then tapping 'Build number' several times. Then, go to Settings->Developer options. I did not find a link directly to 'Developer options', but I did find it by searching for the word 'developer' in Settings. Then enable 'USB debugging'.

Step 3 - Connect your phone to your development computer.

In my case, this required a USB C to A cable. I didn't have one, so I had to go to a local store and buy one.

You may be prompted by your phone to confirm that you want to allow USB debugging.

Step 4 - Make sure the ADB server is running and sees your phone.

The Android Debugging Bridge (ADB) handles communications between your development computer and your android phone. Enter these commands from your terminal.

    adb kill-server
    adb start-server

Verify that your development computer sees your phone by running the following command from your terminal. You may be prompted by your phone to accept the request.

    adb devices

You should get a response like: '4A072DEJH001A2 device'.

If it says your device is 'unauthorized', check the phone for a prompt to authorize the connection, allow it, and run the command again.

Step 5 - Create an new project.

From the directory where you want your new project directory to reside, enter the following commands.

    npx @react-native-community/cli init Buildbotics
    cd Buildbotics

This will create a project in a directory called Buildbotics and then move into that directory.

Add the following section to the "dependencies" section in package.json file in the Buildbotics project root directory.

  "devDependencies": {
    "@react-native-community/cli": "latest"
  },

Now you have a default project built. To actually run it:

• Open a separate terminal and start the 'Metro' server.

    npx react-native start

Then, in the original terminal run this command.

    npx react-native run-android

After this command completes, the default app should appear on your phone.
The next few steps will replace the default app with the Buildbotics app.

Step 6 - Get the files for this project from github.

The files that you will need for this project can be downloaded from my Android-CNC-jogger github repository.

Step 7 - Move the files into your project directory.

1. Copy buildbotics.ts from the github directory to the Buildbotics project root directory.
2. Copy the layout.tsx file from the github directory to the Buildbotics project root directory.
3. Copy the App.tsx file from the github directory to the Buildbotics project root directory, overwriting the existing App.tsx file.
4. Copy the assets folder from the github directory to the Buildbotics project root directory.
5. Copy the AndroidManifest.xml from the github directory to the Buildbotics project root at android/app/src/main/AndroidManifest.xml overwriting the existing AndroidManifest.xml. This step tells your phone to allow cleartext communications.

Step 8 - Install a library from react-native

Run the following command to install the react-native-paper library. This library is needed to run the radio buttons at the bottom of the screen.

    npm install react-native-paper

Step 9 - Replace the app icon

It is recommended to use an icon that is 1024x1024. An image that meets this recommendation can now be found in the assets/images/icon.png directory.

You actually have to make several copies of this and place them in different folders. This is because the icon size depends on the size and model of the android phone.

I happen to have ImageMagick installed on my debian trixie and it comes with a command-line command called convert. With this, I created the following script:

convert $1 -resize 48x48 ./android/app/src/main/res/mipmap-mdpi/ic_launcher.png 
convert $1 -resize 48x48 ./android/app/src/main/res/mipmap-mdpi/ic_launcher_round.png
convert $1 -resize 72x72 ./android/app/src/main/res/mipmap-hdpi/ic_launcher.png 
convert $1 -resize 72x72 ./android/app/src/main/res/mipmap-hdpi/ic_launcher_round.png
convert $1 -resize 96x96 ./android/app/src/main/res/mipmap-xhdpi/ic_launcher.png 
convert $1 -resize 96x96 ./android/app/src/main/res/mipmap-xhdpi/ic_launcher_round.png
convert $1 -resize 144x144 ./android/app/src/main/res/mipmap-xxhdpi/ic_launcher.png 
convert $1 -resize 144x144 ./android/app/src/main/res/mipmap-xxhdpi/ic_launcher_round.png
convert $1 -resize 192x192 ./android/app/src/main/res/mipmap-xxxhdpi/ic_launcher.png 
convert $1 -resize 192x192 ./android/app/src/main/res/mipmap-xxxhdpi/ic_launcher_round.png    

Then, I saved the script as 'make_icons' in my ~/.local/bin folder which s part of my path.

Then, I ran the command from my project root dirctory like this:

    make_icons ./assets/images/icon.png

Step 10 - Start the Metro server.

The Metro server provides the web server interface for development and communicates with the app on the android phone. If it's already running, kill it and run the following command. Note, this command does not return until you kill it (^C on from the linux command line), so it's best to run it from a separate terminal window.

    npx react-native start

Step 11 - Build the app for the android.

The following command builds the app specifically for the android.

    npx react-native run-android

Step 12 - Test the app in development mode

At this point the app should be displayed on the screen of your phone. It should look like this.

Now is a good time to try it out. Just enter the IP address for your Buildbotics CNC Controller in the input field at the top of the page and press the 'Connect' button. The host name should appear and the machine state (hopefully "READY") should also appear. If so, click the big triangle buttons to jog your machine. Select the axis from the X, Y, and Z buttons at the bottom of the screen. Adjust the jogging speed with the up arrow and down arrow buttons near the top of the screen.

Step 13 - Build the app for production and disconnect from the development machine.

Run the following commands to build the production app for the android phone.

    cd android
    ./gradlew assembleRelease

Now, move back up to the Buildbotics project root directory and install the production app on your phone with the following command.

    cd ..
    adb install android/app/build/outputs/apk/release/app-release.apk

That's it! Disconnect the phone from the USB cable. There should be a new icon on your screen that has the Buildbotics logo in it. Just touch that icon when you want to run the app.

Conclusion

As you know by now, we started from a default project, added a couple of source code files, replaced an existing file, and added a few images.

The source code files are written in TypeScript which is Javascript with extensions for type checking. Check out this tutorial if you want to learn more about TypeScript.

The source files are:

• buildbotics.ts - This file contains the code for interfacing with the Buildbotics Controller. Check out my blog post titled Introduction to the Buildbotics CNC Controller API to learn more about the Buildbotics Applications Programming Interface.
• _layout.tsx - This file manages the layout and widgets that appear on the screen of the android phone.
• app.tsx - This is the main app and manages communications between buildbotics.ts and _layout.tsx

Please consider joining the buildbotics forum and contributing to the Applications Development board.

Introduction

The good people over at PwnCNC are now offering a nice Automatic Tool Changing (ATC) System, and one of my customers asked if it was compatible with the Buildbotics CNC Controller. I didn't know for sure, so I sent an e-mail to PwnCNC and they readily agreed to loan me a system so I could try it out with the Buildbotics CNC Controller.

It works great with our latest hardware (V17) and latest software (V2.0.4). This table summarizes what you can expect with earlier versions of our hardware and software.

This article describes how to integrate the PwnCNC ATC system with a Buildbotics CNC Controller that has V17 or later hardware and V2.0.4 or later software.

Overview

The Buildbotics Controller connects to the PwnCNC Pneumatic Enclosure(PE) and the PwnCNC Variable Frequency Drive(VFD) through a DB25 breakout box that is connected to the back of the Controller.

I recommend getting the ATC System running in manual mode first. Then, connect and configure the Buildbotics CNC Controller. The major steps are:

• Install the PwnCNC ATC System on your machine for manual operation.
• Connect the Buildbotics CNC Controller to the PwnCNC ATC System.
• Install the tool holders.
• Configure the Buildbotics CNC Controller.

Installing the ATC System for manual operation

Manual operation means that you can control the pneumatic chuck in the ATC spindle with a button. This makes tool changes much easier and faster, but still requires human intervention.

The PwnCNC ATC system comes with quite a few parts, and they describe them here.

PwnCNC describes how to get the system running in manual mode here.

Connect the Buildbotics CNC Controller to the PwnCNC ATC System

Both the VFD and PE connect to the BB Controller through a DB25 breakout box.
The BB Controller communicates with the VFD using a Modbus/RS-485 connection. The connector on the VFD is compatible with a 2-pin GX12 aviation plug.

Plug the modbus cable into the Modbus connector on the VFD.

Connect pin 13 (rs485a) on the DB25 breakout box to pin 1 on the VFD Modbus connector and connect pin 14 (rs485b) to pin 2 on the VFD modbus connector.

Note, it is recommended that the two RS485 wires be twisted at about 1 turn per inch to reduce noise interference.

PwnCNC provided this control cable for connecting to the PE.

They also provided this cable for extending the control cable to a another controller.

Plug the control cable into the Ctrl port on the PE and connect the extension cable to the control cable.

Connect the black wire (labeled Ground) from the extension to any of the ground wires on the DB25 breakout box. I chose pin 25.

The green wire (labeled Relay 1/Output 7) opens the air supply to the tool and dust outputs on the PE so a tool can be inserted. Connect the green wire to any unused digital output on the DB25 breakout box. I chose pin 15.

The red wire (labeled Relay 2/Output 8) opens the air supply to the addl output and can be used for other purposes. Connect the red wire to any unused digital output on the DB25 breakout box. I connected the red wire to pin 16 but am not using it in my system.

The extension has a yellow wire (labeled Drawbar/Input 7) that is connected to a red wire (labeled Power) This connection to power is not needed and you should cut the connection to the red (Power) wire, leaving the yellow wire intact.

Similarly, The extension has a white (labeled Tool Preset/Input 7) that is connected to a red wire (labeled power) This connection to power is not needed and you should cut the connection to the red (Power) wire, leaving the white wire intact.

Important! - The yellow and white wires from the PE present 24Volts DC when inactive and ground when active. If your Buildbotics Controller uses a board that is older than Version 15, a diode is required to protect the internal circuitry from the 24 Volt connection.

These connections are not absolutely required to make the ATC system and I recommend leaving them off for older Buildbotics Controllers. However, if you insist on connecting them, then connect low drop shottkey diodes (e.g. 1N4001) in line with the yellow and white wires to protect the circuits. The diode cathodes should point toward the PE.

If you don't know what version of main board your controller utilizes, you can contact Buildbotics at 707-559-8539 for that information.

You should also be aware that connecting the yellow or white wire to any pin other than a digital input will damage the Buildbotics Controller even if you have Version 15, or later, main boards.

Assuming your controller utilizes a Version 15 or later main board, then choose any unused digital input pin on the DB25 breakout board and connect the yellow wire to that pin. I chose pin 11 for the yellow wire.

Similarly, assuming your controller utilizes a Version 15 or later main board, then choose any unused digital input pin on the DB25 breakout board and connect the white wire to that pin. I chose pin 12 for the white wire.

Installing the tool holder

PwnCNC included four 3D printed tool holders with the system. I didn't want to drill holes in my table for this temporary installation, so I built this stand and screwed the 3D printed tool holders to the stand.

Then, I used workpiece hold-down clamps to hold it in place.

Configuring the Buildbotics Controller

With the system working in manual mode and all the connections intact, now is a good time to configure the Buildbotics Controller. To do this, we have to select the correct VFD, assign the digital I/O points, and tell the controller how to change tools, and how to park the last tool used at the end of a gcode program.

Selecting the VFD.

Use the following steps to select the PwnCNC VFD.

1. Go to the SETTINGS->Tool page on the Buildbotics Controller.
2. If the 'Login' button is green, click it and log in.
3. Select 'EM60' from the 'tool-type' drop-down menu.
4. Click the green 'Save' button.

If everything is working correctly, the Status field should say 'Ok' and the Failures field should not be increasing.

If the status field does not say OK or the Failures field is increasing try the following things.

1. Verify that the VFD is turned on.
2. Verify that the VFD is switched to 'Auto'.
3. Verify that the connections to the 'Modbus' connector on VFD is properly seated.
4. Verify that the pins 13 and 14 on the DB25 connector are securely connected.
5. Verify that the DB25 breakout box is plugged into the back of the Buldbotics Controller and properly seated.
6. Try reversing the connections between pin 13 and 14 on the DB25 breakout box.
7. Call Buildbotics at 707-559-8539.

After the "Status' field says 'Ok' and the Failures field has stopped increasing, you can test the interface. Here's how:

1. Navigate to the CONTROL page on the Buildbotics user interface.
2. Select the 'MDI' tab.
3. Enter M3S10000 and click play to turn the spindle clockwise at 10000 RPM.
4. Enter M4 and click play to cause the spindle to stop and go in reverse at 10000 rpm
5. Enter M5 to stop the spindle.

Configuring the digital I/O points

Follow these steps to configure the digital inputs:

1. Navigate to the SETTINGS->I/O page.
2. Find the pin that you connected to the yellow wire from the Ctrl extension cable. In my case, that is pin 11. Change the drop-down menu selection in the 'Function' column to 'input-0' and change the drop-down menu selection in the "Mode' column to 'normally-open'.
3. Find the pin that you connected to the white wire from the Ctrl extension cable. In my case, that is pin 12. Change the drop-down menu selection in the 'Function' column to 'input-1' and change the drop-down menu selection in the "Mode' column to 'normally-open'.
4. Click the green 'Save' button.

You can test this connection by using the manual tool change button to insert and remove a tool from the spindle chuck.

The icons next the the digital input pins will reflect the state of the input.

Input0 should momentarily flash from red to green when you insert or remove a tool from the spindle chuck.

Input1 should be green when a tool is in the chuck and red otherwise.

If the manual changes are working but the icons are not reflecting the correct state, check the wiring between the Buildbotics Controller and the PE.

Follow these steps to configure the digital output ports.

1. Find the pin that you connected to the green wire from the PE Ctrl cable extension. Pin 15 in my case. Then,select 'output-0' from the drop-down menu in the 'Function' column and select 'lo-hi' from the drop-down menu in the 'Mode' field.
2. Similarly, Find the pin that you connected to the red wire from the PE Ctrl cable extension. Pin 16 in my case. Then,select 'output-1' from the drop-down menu in the 'Function' column and select 'lo-hi' from the drop-down menu in the 'Mode' field.
3. Click 'Save'

Use the following steps to test the digital outputs:

1. Navigate to the CONTROL Page.
2. Select the MDI tab.
3. Enter 'M64 P0' and click play.
4. You should now get non-zero readings on the tool and dust guages on the PE and air should be blowing in the spindle.
5. Enter 'M65 P0' and click play.
6. The tool and dust guages should go to zero.
7. Enter 'M64 P1' and click play.
8. The 'addl' guage should be non-zero.
9. Enter 'M65 P1' guage should read zero again.

If the guages don't respond properly, try the following things:

1. Verify that the PE is turned on.
2. Verify that the air compressor is turned on and air is getting to the PE.
3. Look at the icons next to pins 15 and 16 on the SETTINGS->I/O page to make sure they are changing state. If not, check the configuration.
4. Check the wiring between the DB25 breakout box and the PE.

Telling the Buildbotics Controller how to change a tool

In order for the Buildbotics Controller to automatically change tools, it needs to know where each tool is located, how long the tools are, what to do when a tool change is requested, and how to park the last tool at the end of the program.

Locating your tool holders

Use the following procedure to locate your tools.

1. Clear all offsets.
2. Home your machine and do not set any offsets.
3. Use the gamepad to jog your spingle to a height where it can move to any place on the table without running into anything. For me that height, which I'll call 'zSafe', is 200mm. Record the 'absolute' position of the Z axis.
4. Use the gamepad to jog the spindle into a position directly above the tool location for your reference tool. You should center it perfectly over your tool holder. My reference tool is tool 1 and it is simply one of the ISO20 ER20 tool holders that was provided by PwnCNC with no tool. Since there is no tool, its length will be zero.
5. Jog the Z axis to a position where it can safely drop the tool into the holder using the MTC button. Record the 'absolute' position of the Z axis. For me, that height is 43mm, which I'll call 'zDrop'.
6. Jog the Z axis to a position where the you can pick up the tool from the tool holder using the MTC button. Record the 'absolute' position of the Z axis. For me, that height is 11mm, which I'll call 'zPick''.
7. For each tool, find and record the 'absolute' positions for the X and Y axes.

Measuring the length of your tools

Use this program to measure the length of each tool:

%
M70
G21
M0 (MSG, insert the reference tool and attach the probe)
F100
G91
G38.2 Z-100
#31 = #5422
G0 Z50
M0 (MSG, insert tool to be measured)
G38.2 Z-100
#32 = [#5422 - #31]
G0 Z50
M0 (DEBUG, tool length is #32 mm)
M72
%

I recommend copying this code into a text file named something like 'measure_tool.ngc', uploading that file to the BB Controller and assigning it to a Macro button.

Run the program using the following steps:

1. Put a reference tool in the chuck. (I use one of the ISO20 ER20 tool holders with no tool as a reference.)
2. Connect your height probe and place it on the CNC work surface.
3. Jog the spindle into a place above your height probe.
4. Click the tool measurement macro button.
5. Connect the ground clip on the height probe to the reference tool.
6. Wait for the controller to touch the probe and prompt you to put the tool to be measured in the chuck.
7. Put the tool to be measured into the chuck.
8. Click 'Continue'.
9. Wait for the BB Controller to probe with the tool and display the length.

The length displayed will be the difference between the reference tool and the tool to be measured, which is the information needed for each tool.

You can see this in action on my Youtube video that demonstrates the use of this tool measurement program.

Also, check out my blog article titled CNC Macro Buttons to see how to create a macro button.

Telling the controller what to do when a tool change is requested

This program will reside in the 'tool-change' box on the SETTINGS->General page, and will be executed every time an 'M6TX' gcode command is encountered.

g4 p1
(Runs on M6, tool change) 
M70
G21
#<_zSafe> = 200
#<_zDrop> = 43
#<_zPick> = 11

#<_zDust> = [#<_zPick> + 10]
#<_tool_table> = 2000 (store x location, y location, an tool length for each tool)

o<_make_tool> sub
  #[#<_tool_table> + [#1 * 3]] = #2 (x location)
  #[#<_tool_table> + [#1 * 3] + 1] = #3 (y location)
  #[#<_tool_table> + [#1 * 3] + 2] = #4 (z location)
o<_make_tool> endsub  

(tool table is arguments to _make_tool call, arguments are:)
(tool number, x park position, y park position, tool length)
o<_make_tool> call [1] [-390] [-525] [0]
o<_make_tool> call [2] [-390] [-465] [46.2]
o<_make_tool> call [3] [-390] [-405] [32.8]
o<_make_tool> call [4] [-390] [-345] [27]

M66 P1 L0
o100 if [#<_x_homed> NE 1 or #<_y_homed> NE 1 or #<_z_homed> NE 1]
	(MSG, Error: System must be homed for ATC Operation)
	M2
o100 elseif [#5399 EQ 1 AND #5400 EQ -1]
    (DEBUG, Error: Unidentified tool is in the chuck #5400)
o100 elseif [#5400 NE #<_selected_tool>]
    #<xret> = #5420
    #<yret> = #5421
    M5 (stop the tool and wait five seconds)
    G4 P5
    o101 if [#5400 NE -1]
        (park the old tool)
        G53 G0 Z#<_zSafe>
        G53 G0 X#[#<_tool_table> + [3 * #5400]]Y#[#<_tool_table> + [3 * #5400] + 1] 
        G53 G0 Z#<_zDrop>
        M64 P0
        G4 P2
        M65 P0
        G53 G0 Z#<_zSafe>
        #<new_offset> = [#5213 - #[#<_tool_table> + [3 * #5400] + 2]]
        G92 z[#<_zSafe> - #<new_offset>]
    o101 endif
    (get the new tool)
    #<t> = #<_selected_tool>
    G53 G0 Z#<_zSafe>
    G53 G0 X#[#<_tool_table> + [3 * #<t>]]Y#[#<_tool_table> + [3 * #<t>] + 1]
    G53 G0 Z#<_zDust>
    M64 P0
    F300
    G53 G1 Z#<_zPick>
    M65 P0
    G4 P2
    G53 G0 Z#<_zSafe>
    #<new_offset> = [#5213 + #[#<_tool_table> + [3 * #<_selected_tool>] + 2]]
    G92 z[#<_zSafe> - #<new_offset>]
    G0 X#<xret> Y#<yret>
o100 endif    

M6
M72

Use the following steps to modify this file with the values, tool numbers, tool locations, and tool lengths from previous steps.

1. Copy the program into a text editor so you can easily edit it.
2. Change the value for zSafe on line 5 to the value you recorded for zSafe.
3. Change the value for zDrop on line 6 to the value you recorded for zDrop.
4. Change the value for zPick on line 7 to the value you recorded for zPick.
5. For each tool starting at line 20, modify the arguments with the tool number, x location, y location and tool length. For instance the second line (line 21 in the program) for my system shows that tool 2 is located at -390mm on the X axis, -465mm on the Y axis, and has a relative length of 46.2mm.
6. Copy all the contents of the file and paste them into the 'tool-change' textbox on the SETTINGS->General page and then click 'Save'.

Parking the tool at the end of the program

I like to park the tool and move the spindle to a convenient place at the end of a gcode program because:

1. The last tool used by a program is retained by the system. However, if the controller is turned off, it loses this information. Then, if you try to run a program after turning the controller back on and the previous tool is still in the chuck, it could cause a crash. Parking the last tool at the end of the program and setting the tool to '0' avoids this problem.
2. I like to move the spindle to a position near my limit switches. This way, when I turn the controller off and back on, homing is much faster because the spindle is already close to it's home position. For me that position is Z=175, X=380, Y= -550.

The following program drops the last tool used by the program into its tool holder and parks the spindle near the homing limit switches.

(Runs on M2, program end)
M70
G21
o200 if [#5400 GT 0]
    M5 (stop the spindle and wait 5 seconds)
    G4 P5
    (park the old tool)
    G53 G0 Z#<_zSafe>
    G53 G0 X#[#<_tool_table> + [3 * #5400]]Y#[#<_tool_table> + [3 * #5400] + 1] 
    G53 G0 Z#<_zDrop>
    M64 P0
    G4 P2
    M65 P0
    G53 G0 Z#<_zSafe>
    #<new_offset> = [#5213 - #[#<_tool_table> + [3 * #5400] + 2]]
    G92 z[#<_zSafe> - #<new_offset>]
o200 endif
M6T0
#5400 = -1
(park near the limit switches)
G53 G0 Z175
G53 G0 X380 Y-550
M72
M2

Use the following steps to modify this program with your preferred park position and load it into your Buildbotics Controller.

1. Copy the program into a text editor so you can easily edit it.
2. Change the Z value on line 20 to your preferred Z axis park position.
3. Change the X and Y values on line 21 to your preferred X axis and Y axis park positions.
4. Copy and paste it into the 'program-end' textbox on the SETTINGS->General page and then click 'Save'.

Relavant links

Check out my video titled Integrating the PwnCNC Automatic Tool Changer with the Buildbotics Controller to see the system actually doing a cut.

Also check out my video titled Measuring tools for an Automatic Tool Changer using a macro button on a Buildbotics Controller to see the tool measurement macro in action.

Finally, check out my blog article titled CNC Macro Buttons to see how to create a macro button.

Read the Buildbotics Controller's API documentation on GitHub.

Macro Buttons are one of many features that set the Buildbotics CNC Controller apart from other controllers.

In a 'nutshell', you can assign any GCode program to a button that appears on the Control page. Then, the associated program will execute each time you click the button.

Assigning Macros

Click the 'Macros' button on the CONTROL Page to add, delete or modify Macro buttons.

Click the 'trash' button to remove an existing Macro button.

To add a new Macro button:

• Click the '+ Add' button.
• Select the color using the color selector.
• Assign a name in the field next to the color selector.
• Click the folder icon to select an existing GCode program.
• Click the green 'Save' button to save your work.

The new button will appear on the CONTROL page. Now each time that button is clicked, the associated program will execute.

Example

A program was created to execute 3D probing in my Probing article. Watch my probing video to see a macro button in use.

I saved that program as 3DProbeRick.gc on my local desktop computer and then uploaded it to the Buildbotics Controller via the web interface.

Then, I assigned the program to the pink Macro button shown above.

Homing allows your CNC Controller to learn about the boundaries of your CNC machine. In this article, I'll explain why it helps and how to set it up with a Buildbotics CNC Controller.

Why bother?

Honestly, homing with a Buildbotics Controller is not absolutely necessary. But it does provide two important advantages.

First, it lets the controller know the boundaries of the physical machine. This prevents running into an endstop, which can be pretty hard on your machine.

Second, once a machine is homed, you can tell it to move to some specific absolute position and that absolute position will always be at the same place on the machine. For instance, you may have a jig on your table where you like to lay down a workpiece. If the machine is homed, that location will always be at the same absolute position. Check out my article on 'Macro Buttons' to see how to make things even easier.

You may have noticed that I am using the phrase 'absolute position'. The absolute position is the position relative to the machine boundaries. The cutting position or just 'position' can be different from the absolute position if the position offsets have been adjusted. Check out my article titled 'CNC Offsets (absolute position vs cutting position)' to learn more about position offsets.

What hardware is needed for homing?

Homing relies on the ability to trigger an event when an axis reaches a known position. On the Buildbotics Controller, that event is either opening or closing a switch. These switches are known as limit switches. There are several kinds of limit switches including magnetic reed switches, optical switches, proximity switches, and mechanical lever switches. The one thing that they have in common is that they provide a state change on a pair of wires that can be detected by the controller.

I usually use magnetic reed switches like the ones shown below because:

• They are easy to install.
• They have no mechanical parts that can fail.
• They're cheap.
• They do not require power.
• The activation position seems to be very consistent.
• They never make physical contact. I can install them in a way that the magnet slides past the reed rather than running into it.

The one drawback is that they don't work very well when cutting ferrous materials.

The reed switches change state when the magnet comes into close proximity with the reed relay.

How do you connect the switch to the Buildbotics Controller?

Each limit switch gets connected to one of the digital inputs on the DB25 Breakout box. Simply pick any unused digital input pin. We'll configure the controller later.

If the limit switch is passive (non-powered), simply connect one of the wires to digital input pin and the other wire to a ground pin.

If limit switch is powered, connect the positive wire to a digital input and the ground wire to one of the ground pins.

Then plug the DB25 breakout box into the back of the Buldbotics Controller.

How to configure limit switches in the Buildbotics Controller

Limit switches are configured on the SETTINGS->I/O page on the Buildbotics Controller.

Do the following things for the digital input pin that you selected:

• Select the function from the pull-down menu in the Function column. For instance, if the switch is positioned at the maximum end of the axis served by motor port 0, then the function would be 'input-motor-0-max'
• Select the mode from the pull-down menu in the Mode column. This will be 'normally-open' if the switch is open or presents a high signal when it is not active. It will be 'normally-closed' if the switch presents a low signal or is closed when it is not active.

The icons in the State column report the current state of the switch and are really handy for troubleshooting your switch and connection.

• If the icon is green, the switch is active.
• If the icon is red, the switch is not active.
• If there is a '+' in the icon, the input is high or open.
• If there is a '-' in the icon, the input is low or closed.

You can operate the switch manually while watching the icon to make sure it's doing what you expect.

How to configure homing

Homing is configured on the SETTINGS->Motor pages.

Here's how to configure an axis for homing on the Buildbotics Controller:

1. Go to the SETTINGS->Motor page for the motor port serving the axis and login.
2. Set the absolute position of the minimum and maximum soft limits for the axis. The image above is the configuration for my X axis. It has 830 mm of available travel and I like to set the absolute position right in the middle. As a result, I have set the lower soft limit to -415mm and the upper soft limit to +415mm.
3. If you mounted your limit switch at the maximum end of the axis, set the homing-mode to 'switch-max'. Or, if you mounted the limit switch at the minimum end of your axis, set it to 'switch-min'. My switch is at the maximum end, so it is set to 'switch-max'.
4. Set the 'search-velocity' to the speed at which the machine will search for the switch. If it's too fast, it may may not be able to stop in time and damage your machine. If it's too slow, it will take a long time to find the switch. I have my X-axis set to search at 2 meters per minute.
5. Once the switch changes state, the machine will back off by the distance assigned in the 'latch-backoff' field. My X-axis is set to back off my 15mm once the switch is found. This allows the switch to change back to it's inactive state before approaching again.
6. The 'latch-velocity' sets the speed at which the axis will approach the switch again. This slower speed will provide a more repeatable position where the switch activates. My X-axis is set to .5 meters per minute.
7. Set 'zero-backoff' to the distance that the axis backs away from the switch after the homing sequence is complete.

When the homing sequence is complete, it will set the absolute position to the position defined in the soft limit. If the 'homing-mode' is 'switch-max', the absolute position will be set to the 'max-soft-limit' value. If the 'homing-mode' is 'switch-min', the absolute position will be set to the 'min-soft-limit' value. My X-axis is set to 'switch-max', so it comes to rest at the right end of my axis at an absolute position of +415mm.

How to home the machine

The homing buttons are located on the CONTROL page at the right side of the 'axis table'. Each axis can be homed individually by clicking the 'Home' button for that axis. Clicking the 'Home All' button initiates the homing sequence on all axes.

Summary

Homing teaches the Controller where the boundaries of the physical machine are located. This provides the following advantages:

• Since the controller knows where the boundaries are located, it can prevent crashing into the endstops.
• Commonly used locations on your machine will always be located in the same absolute position. This allows you to return to that exact position from any location after homing, even if the contoller is rebooted. Check out my article on 'Macro Buttons' to see how to make things even easier.

CNC machines 'probe' to find the workpiece and then set the Offsets accordingly. Probing is controlled using G-Code commands on the Buildbotics CNC Controller.

The most common use of probing is to adjust the offset for the z-axis after a bit is changed. This allows changing bits during the execution of a single GCode program.

This article describes how to use probing on a Buildbotics CNC Controller but the concepts are also applicable to most other controllers.

Also, check out my video on 3D Probing.

What is a CNC probe?

A probe is a simple device that provides a state change on a pair of wires when it comes in contact with the bit on your CNC machine. All you really need is a metal plate with a known height that has two wires connected. I use one like the one shown below, but it wouldn't be hard to make your own. These probes are readily available for just a few dollars.

How to connect the probe to your controller

Simply connect the wire that attaches to the metal plate to one of the digital inputs on the Buildbotics Controller and connect the other wire to one of the ground leads on the Buildbotics Controller. Both connections are made through the DB25 breakout box that comes with the controller.

How to configure the probe.

Go to the SETTINGS->I/O page to configure the input pin that you selected for the probe. Pin 22 is used in the image below. Set the function for the pin to 'input-probe'. Then, set the Mode to 'normally-open'. Click the green 'Save' button to save your work.

The icons in the State column report the current state of the input and are really handy for troubleshooting your probe and connections.

• If the icon is green with a '-' sign, the probe plate is touching the ground connection.
• If the icon is red with a '+' sign, probe plate is not touching the ground connection.

How to use it

The probe provides a known height that allows you to determine height of the tip of the bit. For instance, my probe plate is 3/4" (19.05mm) tall. If the bit is just touching the probe plate then it is 19.05 mm above the top surface of the workpiece. I always set up my GCode designs so that the top surface of the workpiece is set to 0. So, all I have to do is set the height to 19.05mm when the probe touches the workpiece.

Start by connecting the probe to the controller, placing the probe plate on the top surface of the workpiece, and moving the tool to a place just above the probe plate.

Issue the following GCode commands to use metric units and set the speed at which the tool will approach the probe.

G21 (use metric units)
F100 (sets the feed rate to 100 mm/minute)

Then, issue the following command to tell the controller to move down towards the probe and stop when contact is made or fail if it moves down by 100mm without making contact.

G38.2 Z-100 

Then, use the following command to set the Z-axis position to 19.05mm.

G92 Z19.05

You can do these commands manually with from the MDI interface on the CONTROL page on the Buildbotics Controller, or you could put these commands into a Macro button.

Automating the process

Lumping the GCode commands into a macro provides some convenience, but it still does not allow you to change bits while running a GCode program. You could issue the commands from within the GCode program, but the Buildbotics Controller provides a better way.

You can configure the Buildbotics Controller to automatically issue a block of commands every time a tool change is encountered. Simply enter the required commands into the 'tool-change' text box on the SETTINGS->General page.

M70 (save the current machine state. (e.g. feed rate and units)
G21 (metric units)
G90 (set the machine to "absolute distance mode")
G0Z50 (raise the spindle to a height that makes it easy to change the bit)
G0 X-50Y-50 (make a rapid move to a good place to sit the probe plate)
M0 (MSG, Change bit and attach probe) (prompt the user to change the bit and attach the probe)
G91 (put the machine in "incremental distance mode")
F100 (set the feed rate to a slow speed for probing)
G38.2 Z-100 (probe down until the plate is touched or until Z has moved by -100mm)
G92 Z19.05 (set the Z axis to the height of the probe plate)
G90 (set the machine to "absolute distance mode")
G0 Z50 (raise the Z axis to a safe height where it is easy to remove the probe.)
M0 (MSG, Remove the probe) (prompt the user to remove the probe)
M72 (recover the original machine state(e.g. feed rate, distance mode, and units))

(to use this program, simple place the probe plate on the front, left corner of the workpiece)
( and move the bit over the circle at about 1" above the plate, then run the program)

(All dimensions should be entered in millimeters)

#<_x_outer_dim> = 63.18 (Change to the outer size of the probe plate in the x direction)
#<_x_inner_dim> = 53.92 (Change to the size of the inset part probe plate in the x direction)
#<_y_outer_dim> = 63.28 (Change to the outer size of the probe plate in the y direction)
#<_y_inner_dim> = 54.34 (Change to the size of the inset part probe plate in the y direction)
#<_height> = 18.88 (change to the overall height of the probe plate)
#<_inset_height> = 14.9 (change to the height of the inset part of the probe plate)
#<_circle_x> = 10 (change to the approximate circle x position on the probe plate)
#<_circle_y> = 10 (change to the approximate circle y position on the probe plate)

M70 (push state)
G21 (Change to metric units)
M5 (stop the spindle)

(prompt the user to attach probe and confirm that it is over the circle)
M0 (MSG, Attach probe and confirm that the center of the bit is over the circle)

G92 X0Y0Z0 (set all offset positions to 0)
F100 (set the feed rate to 100 mm/min)

(the next set of commands determine z height)
G38.2 G91 Z-100 (probe z by as much as 100 mm)
G92 Z[#<_inset_height>] (set z-axis to the height of the probe)

(the next set of commands determine the radius of the bit)
G0 G90 Z[#<_inset_height> + 10] (raise z to 10 mm above the top of the probe plate)
G0 G91 X[#<_x_outer_dim> - #<_circle_x> + 20] (rapid x to approximately 20mm past the right side of the probe)
G1 G90 Z[#<_inset_height> - 5] (move to 5mm below the top surface of the probe plate)
M0 (MSG, align flute for x probe)
G38.2 G91 X-25 (probe by up to 25mm to the left to find the right edge of the probe plate)
#<_right_side> = [#<_x>]
G0 G91 X1 (back off by one mm)
G0 G90 Z[#<_inset_height> + 10] (rapid to safe height)
G0 G91 X[-1 - #<_x_outer_dim> - 20] (rapid to the 20 mm past the left edge of the probe plate)
G1 G90 Z[#<_inset_height> - 5] (move to 5mm below the top surface of the probe plate)
M0 (MSG, align flutes for x probe)
G38.2 G91 X25 (probe by up to 25mm to the right to find the for left edge of the probe plate)
#<_left_side> = [#<_x>]
#<_diameter> = [#<_right_side> - #<_left_side> - #<_x_outer_dim>]
#<_radius> = [#<_diameter> / 2]

(now set the x postion to be 0 - 'x outer dimension - x inner dimension' - radius)
G92 X[0 - #<_x_outer_dim> + #<_x_inner_dim> - #<_radius>]

(next set of commands probe y and set y position)
G0 G91 X-1 (back away by one mm)
G0 G90 Z[#<_inset_height> + 10] (rapid to safe height)
G0 G91 X[1 + #<_radius> + #<_circle_x>] Y[-#<_circle_y> - 20] (rapid to the circle x pos and 20 mm below the lower y edge)
G1 G90 Z[#<_inset_height> - 5] (move to 5mm below the top surface of the probe plate)
M0 (MSG, align flutes on [#<_radius>] bit for y probe)
G38.2 G91 Y25 (probe by up to 25mm to back to find the front edge of the probe plate)

(now set the y postion to be 0 - 'y outer dimension - y inner dimension' - radius)
G92 Y[0 - #<_y_outer_dim> + #<_y_inner_dim> - #<_radius>]
G0 G91 Y-1 ( back away by one mm)
G0 G90 Z[#<_inset_height> + 10] (rapid to safe height)
G0 X0 Y0(move to the front left corner of the workpiece)
M0 (MSG, Remove probe)
M72

After the Buildbotics CNC Controller is booted, it simply assumes that the cutting head is located at the origin (all axis positions are set to zero). Homing the machine leaves the axes near their limit switches at known positions. Check out my article titled 'Homing your CNC machine' to learn all about homing the Buildbotics Controller.

This is all great, but the CAD programs typically define the origin as a location on the workpiece. It's pretty safe to say that the GCode origin is different from the machine origin. That's where offsets come into play.

After homing, my machine thinks the origin is in the center of the table. The picture below shows that the machine origin is in the center of the machine but I laid the workpiece down near the front right side of the machine.

The GCode program expects the origin to be at the top, left, front corner of my workpiece.

The goal is to adjust the offsets such that the machine origin is in the same place as the GCode origin.

One way is to jog the machine into position with the game pad and then set the offsets.

As you jog the tool around, you will notice that the 'Position' and 'Absolute' fields remain equal to each other and the Offset fields remain at zero. The next picture shows my display after jogging to the gcode origin.

Now, click the top Zero offset button to set the current positions to zero. The picture below shows that the offsets have been set. Notice 'Absolute' remains the same but Position is now all zeros and Offset shows the difference between the two.

Summary

This article shows a brute force method of setting the offsets. It works pretty well until you need to change bits in the middle of a program.

This method requires that you take control of the machine to set the offsets. Many GCode programs require tool changes in the middle of the program and unless you have an automatic tool changer, the bit position is likely to be different each time you change it. In the method shown, you would have to run individual programs each time you want to use a different bit.

This problem is solved by initiating a probing sequence after each tool change. Check out my article titled 'Probing to set CNC offsets' and my 3D probing video.

Introduction

This article describes how I set up a rotary axis on my homemade CNC machine. This article describes the setup using my Buildbotics CNC Controller, but the concepts should be applicable to most other CNC controllers.

Check out my youtube video that shows my first cut with this rotary axis.

Setting up the hardware

When I built my CNC Machine, I set up the Z axis with 10 inches of movement. I eventually wanted to add a rotary axis and figured I needed this extra space so I could place the rotary hardware on the table and raise Z high enough to get the spindle over the work piece.

Then, I bought this rotary axis set off of Amazon. It came with a 100 mm, 4-jaw chuck.

I finally got around to setting it up on my machine, and here's the result.

The hardware set up was pretty easy. I rewired the Y-axis motors in parallel and connected them to the Motor port 1. This freed up Motor port 3 so I could assign it to the A axis for rotary motion. I had to reduce the top speed on my Y axis a bit to prevent stalling, but rapid moves are still 300 inches per minute.

Configuring the rotary axis

Configuring the rotary axis was a bit more difficult. The axis had to be configured for linear movement in either millimeters or inches, but the axis actually turned. I figured that I needed to calibrate such that a move given in millimeters would actually travel that far in degrees.

The rotary hardware actually turns the chuck one revolution for every six revolutions of the motor. So, I reasoned that if I set the travel-per-revolution to 60 mm, it would work. And it did! Now, I could give it a command like "G0A90" and the chuck would turn by 90 degrees.

Unfortunately, this setup had two major problems:

1. Switching to Imperial units caused the turning distances to be off by a factor of 25.4. For instance, a command like "G0A360" would cause the chuck to turn by 25.4 revolutions. This meant that I would have to reconfigure the axis everytime I switched between Metric and Imperial units.
2. The feed rates are based on linear travel distance, but the rotary axis traveled in degrees. As a result, the feed rates were incorrect unless the cutting point was exactly 57.3 mm from the center of rotation

A better solution is to treat the axis as if it were a linear axis and set a 'sensible' travel distance for one revolution of the motor. This method provides the correct cutting distance as long as the cutting point is at a specific distance from the center of rotation. Here's how I did it:

1. I decided that the travel distance for one rotation of the chuck would be 10 inches.
2. Since the motor rotates six times for each rotation of the chuck, the travel-per-revoltion would be 10 / 6 = 1.667 inches.
3. I like to configure my machine in metric units so I converted 1.667 inches to 42.33 mm and entered that value into the travel-per-rev field on the Settings->Motor page for my rotary axis.

This distance is correct as long as the cutting point is 1.59 inches from the center of rotation. If the cutting point moves in or out significantly from 1.59 inches, the cutting speed may be off far enough to negatively impact the quality of the cut.

You may want to change the feed rate in your gcode program to compensate for this problem, but be careful because changing the feed rate changes the cutting speed along both axes while the distances are only changing along the rotary axis.

If your CAD software is sophisticated enough, it may be able to calculate and adjust the feed rate for each line segment so that a constant cutting speed is maintained.

In the worst case, you may need to break your project into separate cuts and adjust the travel-per-revolution of the rotary axis between those cuts.

Setting up the origin

In reality, I could move the rotary axis around on my machine, but it is kind of a pain to set it up and move it around. Once I found a good spot, I made some adjustments in the configuration that allow me to set offsets for my cutting origin and then go there at the beginning of each cut.

This works great as long as the machine is homed before you start your program.

On the Buildbotics Controller, this is done in the "program-start" textbox on the "SETTINGS->General" page.

The "G53G0Z100" command tells the machine to ignore existing offsets and move in machine coordinates while raising the Z axis to 100 mm.

The "G53G0X-200A-491" tells the machine to use machine coordinates and move to X=-200mm and A=-491.7 mm. Note that A is actually my linear axis that moves the gantry forward and backward on my machine. The rotary axis is Y. This move puts the tool directly above the center and near the left end of the work piece.

The "G92X0Y0A0" command tells the machine that the current location is the origin for the X, Y, and A axes.

Setting up Z-Axis probing

If you want to change tools during a cut, you will need the ability to probe to adjust the Z-axis offset for each tool that you use.

Probing is set up in the "tool-change" textbox on the "SETTINGS->General" page.

This picture shows the part of the tool change procedure that is automatically inserted into the gcode program every time a tool change is encountered.

The "G0Z100" command tells the Z-axis to move to 100mm to ensure a safe move to the probing location.

The "G0X-140A0" moves the tool to a place directly above the tail-stock housing.

The "G38.2 Z-54" command tells the controller to move down along the Z axis until the probe is tripped or it reaches the minimum soft limit at -54mm.

After the probe is tripped, the "G92 Z47.05" sets the Z axis to 47.05mm.

The Z axis is set to 47.05 mm because the top of the tail-stock housing is 28 mm above the center of rotation and the probe is 19.05 mm (.75 inches) high. 28 + 19.05 = 47.05 mm.

Check out this thread on the Buldbotics Forum for more information on probing.

Be sure to check out my youtube video that shows my first cut using the rotary axis.

These are unpaid independent reviews of the Buildbotics controller.

• July 2021 - Mellow Pine
• November 2021 - Mellow Pine
• August 2017 - Hackster.io

When you first get started with your CNC you will probably try cutting a few preexisting GCodes but soon you will want to make your own.  The first step in that process is to create a drawing using a CAD or drawing software such as LibreCAD (2D) or Inkscape (2D).  There are many guides online explaining how to install and use these programs.

Once you have a drawing saved in DXF format you will need to convert it to GCode using CAM software.  You can use commercial programs such as Fusion360 or MasterCAM but there are also free and Open-Source solutions such as CAMotics, Inkscape's gcodetools plugin and pyCAM.  In this guide, we will focus on using CAMotics and TPL.  A quick Internet search will yield guides on using other software.

Using CAMotics and TPL

CAMotics is a free and Open-Source CNC simulation software. It supports a CNC programming system called TPL (Tool Path Language) that makes it much easier to create GCode.

If have experience with JavaScript or similar programing languages then TPL will be very easy to learn. If you have no programming experience, then you can use this guide to cut-and-paste the simple TPL program presented here and make small changes to convert your own DXF files.

Once you've installed CAMotics, try out some of the examples by selecting them from the File menu. The "CAMotics" and "Buildbotics" examples both use DXF files and TPL. Try changing the tool or workpiece options and rerunning the simulation to see how it changes.

Here we will look at the "Buildbotics" example in detail. Double click on buildbotics_logo.tpl from the left hand side of CAMotics to view the program. The complete program looks something like this:

var dxf = require('dxf');
var layers = dxf.open('buildbotics_logo.dxf');

var zSafe = 3;
var cutDepth = -1.5;

units(METRIC); // This must match the units of the DXF file
feed(1600);
speed(10000);
tool(2);

rapid({z: zSafe});

dxf.cut_layer_offset(layers.Inside,  -0.5, zSafe, cutDepth);
dxf.cut_layer_offset(layers.Tools,    0.5, zSafe, cutDepth);
dxf.cut_layer_offset(layers.Head,     0.5, zSafe, cutDepth);
dxf.cut_layer_offset(layers.Ears,    -0.5, zSafe, cutDepth);
dxf.cut_layer_offset(layers.Eyes,    -0.5, zSafe, cutDepth * 0.66);
dxf.cut_layer_offset(layers.Pupils,  -1.2, zSafe, cutDepth * 0.66);
dxf.cut_layer_offset(layers.Outline,    0, zSafe, cutDepth);

rapid({z: zSafe});
speed(0);
rapid(40, 75);

Let's break it down.

var dxf = require('dxf');
var layers = dxf.open('buildbotics_logo.dxf');

The first two lines load in the DXF library and read in the DXF file. Change the filename to read in a different file. The DXF file should be in the same directory as the TPL file. The variable layers now holds the DXF data.

var zSafe = 3;
var cutDepth = -1.5;

Next we set a couple more variables that will be used below. zSafe is the height above the workpiece where the tool can safely make rapid moves. cutDepth is how deep we will be cutting into the material.

units(METRIC); // This must match the units of the DXF file
feed(1600);
speed(10000);
tool(2);

Now we set the units mode to metric. You could also set it to IMPERIAL to use inches instead of millimeters. The feed rate is set to 1600 mm/min, the spindle speed to 10k RPM and tool 2 is selected. These are just examples, you must choose appropriate values for your machine, material and tool.

rapid({z: zSafe});

Move the tool up to the safe height specified above.

dxf.cut_layer_offset(layers.Inside,  -0.5, zSafe, cutDepth);
dxf.cut_layer_offset(layers.Tools,    0.5, zSafe, cutDepth);
dxf.cut_layer_offset(layers.Head,     0.5, zSafe, cutDepth);
dxf.cut_layer_offset(layers.Ears,    -0.5, zSafe, cutDepth);
dxf.cut_layer_offset(layers.Eyes,    -0.5, zSafe, cutDepth * 0.66);
dxf.cut_layer_offset(layers.Pupils,  -1.2, zSafe, cutDepth * 0.66);
dxf.cut_layer_offset(layers.Outline,    0, zSafe, cutDepth);

Here we cut each of the DXF layers using dxf.cut_layer_offset(). The three paramters passed to dxf.cut_layer_offset() are layer, offset, z-safe and cut depth.

The layer is the DXF layer. DXF layers can be selected by name or by number. DXF layers are named in the CAD software. Your DXF may only have one layer. In that case, it is easer to cut the single layer like this:

dxf.cut_layer_offset(layers[0], 0, zSafe, cutDepth);

The offset offsets the tool position from the DXF path. A positive offset will cut outside of the path. For example, you might want to offset by half the tool diameter. A negative value will cut inside the path and zero will cut exactly on the path.

rapid({z: zSafe});
speed(0);
rapid(40, 75);

Finally, we move back up to the safe height, turn off the spindle and move to a position out of the way.

One of the first things you will want to do with your Buildbotics CNC controller is connect it to your network.  For many people, this means connecting to WiFi.  To do so you must configure the controller's WiFi settings.

There are two ways to access the controller's WiFi settings.  Either temporarily connect the controller to a wired network or boot the controller with a monitor, mouse and keyboard connected.  Each of these methods is described in detail below.

Method 1: Using a wired network

If you plug the Buildbotics controller directly into a wired network, the network should automatically assign the controller an IP address.  You can then use that IP address to access the controller from another computer on the same network.  Here's how:

1. Plug in the controller's power supply.
2. Plug an Ethernet cable in to the back of the controller
3. Plug the other end of the Ethernet cable in to your router or network wall socket.
4. Plug the Gamepad into one of the controller's USB ports.
5. Switch the controller on.
6. Wait for it to boot.
7. Press the right arrow on the Gamepad until you see the network page on the LCD screen.

8. On another computer navigate to http:// followed by the IP address shown on the LCD screen.

For example, you might enter http://192.168.0.2 in your browser.  Once you've reached the Buildbotics controller's Web interface, you can move on to configuring the WiFi.

Method 2: Connect a Monitor, Mouse and Keyboard

The Buildbotics controller has a built-in computer which you can use to control your CNC directly.  You will need the following:

1. A monitor with HDMI cable.
2. A USB mouse.
3. A USB keyboard.

If your monitor is a touch screen you may be able to forgo the mouse and keyboard.

Connect the monitor, mouse, keyboard and the controller's power supply.  Turn the controller on and wait for it to boot.  As it starts up you should see the Buildbotics logo.  Once it is fully booted you can move on to configuring the WiFi.

Configuring the WiFi

Once you've gained access to the controller's Web interface using one of the methods described above you are ready to configure the WiFi settings.

To setup the WiFi:

1. Click on the ADMIN -> General tab from the menu on the left.
2. Set the WiFi mode to Client.
3. Set your WiFi network's SSID or name.
4. Set your WiFi network's password.
5. Click the blue Set button.
6. Click the green Ok button to reboot the controller.
7. Wait for it to fully reboot.

Accessing the Buildbotics controller over WiFi

Once you've saved the controller's WiFi settings and allowed it to reboot you should be able to access the controller over WiFi.  If you used a wired network to configure the controller, you should unplug the Ethernet cable now.

As described in method 1 above, use the Gamepad to locate the new IP address on the LCD screen.  It will be different from the wired network IP.  Enter http:// followed by the IP in another computer on the network to access the controller remotely.

Troubleshooting

Here are some common problems and their solutions.  Please feel free to contact us if you cannot resolve your problem.

Problem: Network connects and disconnects.

The Buildbotics controller's built-in WiFi is not particularly strong.  If your WiFi network's signal is weak or there are a lot of other wireless devices in the area it may be difficult to keep the controller connected.  A wired network connection will be more reliable but if you must use WiFi you can add a USB WiFi dongle with an antenna to boost your signal strength.  There are many good inexpensive WiFi adapters available online.

Problem: No IP address on the LCD screen.

First make sure you are on the LCD screens network page by pressing the right arrow on the Gamepad.  If the screen does not change, make sure the Gamepad is plugged in and you are pressing the right button.

If there is no IP address on the Buildbotics LCD screen on its network page, then it is either not connected to a network or the network is not assigning the controller an IP address.  Check the network connections or the WiFi settings.  It that fails, check your local network's configuration.

Problem: The IP address will not load in the browser

Make sure you type a full address such as http://192.168.0.2  If it still does not work, then the computer you are using may not be on the same network as the Buildbotics controller.  The remote computer must be on the same network.

Problem: The controller shows more than one IP address

Your controller may get assigned more than one IP address if it is connected both to the WiFi and to a wired network.  This may also occur if you are using a WiFi dongle to boost your signal.  You can disconnect the other networks and restart the controller or try each IP address until one works.

A VFD or Variable Frequency Drive is a type of motor driver often used to control high speed CNC spindles. The VFD converts AC line voltage to higher voltages and frequencies.  The VFD varies the output frequency to control motor speed.  Using a VFD smart controller, like the Buildbotics CNC controller, you can control spindle speed and direction using GCode and get feedback indicating actual speed in real-time.

You may also be interested in PWM spindle control.

RS485 VFD Control

Most VFDs support remote control using the two wire RS485 digital interface. This allows a smart CNC controller to command the VFD's speed and direction and read back actual speed and status information while the VFD is running.  Most also use a protocol called Modbus when communicating over RS485.  Unfortunately, compatibility ends here because each VFD vendor uses a different set of Modbus commands.

Fortunately, the Buildbotics CNC controller has built-in configurations to handle many common VFDs and makes it possible to create custom configurations to support new ones.

Supported VFDs

Any VFD that supports Modbus can be used with the Buildbotics controller. However, some VFDs have out-of-the-box support and others require custom programming. At the time of this writing the following VFDs are supported out-of-the-box:

• Huanyang
• AC-Tech
• Nowforever
• Delta VFD015M21A (Beta)
• YL600, YL620, YL620-A (Beta)
• FR-D700 (Beta)

VFDs marked as beta have had limited testing.  If you need help with one of these VFDs or would like to create a custom configuration for a new VFD, don't hesitate to contact us.  We will be glad to help decipher the VFD's manual and are eager to add support for more VFDs.

RS485 Wiring

Only two wires are needed to make the RS485 connection. To reduce electrical noise it is best to keep the wires short and to use a shielded twisted pair such as one of the pairs found in a CAT5  network cable.

First, disconnect all power.  Then, make the following connections on the Buildbotics controller I/O breakout box.

You can connect either wire to RS485 A or B; the Buildbotics controller will automatically discover which is which. Consult the VFD's manual for the correct connection points on the VFD.  Be sure not to connect the RS485 wires to any of the high voltage lines with in the VFD.

Buildbotics Controller Configuration

To configure the Buildbotics controller to talk to the VFD go to the TOOL page on the Web interface and configure the following sections:

Tool Configuration

tool-type

Select one of the built-in VFD configurations or "Custom Modbus VFD" to design your own VFD control commands.

tool-reversed

Check this box if your spindle turns the wrong direction.  Most tools require clockwise rotation. That is clockwise if you are looking down from above the spindle towards the workpiece.  Spinning the tool in the wrong direction can cause major problems so double check it before you cut anything.

max-spin & min-spin

Maximum and minimum spindle speed in RPM (Revolutions per Minute).  Check your VFD's manual to determine the correct values for your spindle.  A typical maximum RPM is 10k to 24k.

tool-enable-mode & tool-direction-mode

These options are not normally needed for RS485 VFD control.  Set them disabled.

Modbus Configuration

There are a number of configuration options on the Buildbotics controller that are common to all VFDs.  These options must match the settings applied in the VFD's configuration.

bus-id

This is the Modbus ID.  It is used to identify multiple Modbus devices on the same RS485 network.  Typically there is only one device so bus ID 1 is a good choice.  It just has to match the setting in the VFD.

baud

This is the speed of the RS485 communication in bits per second.  It is tempting to use higher baud rates but this only increases the likelihood of errors due electrical noise.  The spindle control signals are very brief and even at 9600 baud it is already very fast.  For example, a typical command and response consists of 176 bits of data. At 9600 baud that takes about 1/50th of a second.

parity

The parity bit is an extra bit that is used to help detect communication errors. The Modbus protocol already has it's own error checking so parity is generally set to none. However, it must match the setting in the VFD.

Configuring the VFD

You must configure the VFD for your spindle and enable Modbus communication. If you select one of the preconfigured VFDs, a "Notes" section will appear at the bottom of the page showing the necessary VFD settings.

The configuration process varies for each VFD so consult its manual for details.  It usually consists of using the arrow and enter keys on the VFD's front panel to select an address and then set its value.  This is repeated for each setting until all the necessary settings are configured.

Here are the most common VFD settings needed for Modbus communication:

• Enable RS485 Modbus communication in RTU mode.
• Select 9600 baud.
• Select no parity, 8 data bits and 2 stop bits.
• Set the Modbus slave ID to 1 or whatever you set bus-id to.
• Select Modbus as the start/stop controller and remote frequency source.

You will also need to set the correct frequency, output voltage and min and max RPM for your spindle in the VFD's configuration.

Testing the Connection

With the RS485 wiring complete and the Buildbotics controller and VFD configured, it's time to test the connection.  Test with the spindle disconnected from the VFD until you're sure the VFD is operating correctly.

To start the VFD in the clockwise direction go to the CONTROL page on the Buildbotics controller, select the "MDI" tab, then run the following GCode command:

M3 S1000

Return the the TOOL page to check the Modbus status.  The VFD's front panel may also indicate if it is operating.

Increase the speed with:

S5000

Reverse the direction with:

M4

Stop the VFD by clicking the stop button or with:

M5

Once everything appears to be working correctly, disconnect the power, connect the spindle, power it up and try it again for real. Be sure to check that the spindle turns in the correct direction.

Troubleshooting

VFD fails to operate

Check the following:

• Both RS485 wires are solidly connected to both the Buildbotics controller and the correct connection points on the VFD.
• The following settings match on both the Buildbotics controller and VFD:
  • Modbus ID
  • RS485 baud rate
  • RS485 data bits, parity and stop bits
• The VFD is in Modbus RTU mode. Not ASCII mode.
• RS485 Modbus is the source for start/stop and frequency control on the VFD.
• The VFD can be operated manually through its front panel.

Spindle runs in reverse

If an M3 causes the spindle to turn counter-clockwise you can either correct the configuration in the VFD or set the tool-reversed option on the Buildbotics controller.

Spindle runs at wrong speed

Check that:

• max-spin is correct on the Buildbotics controller.
• The maximum frequency is set correctly on the VFD.
• The VFD program uses either max-freq-read or max-freq-fixed to get the VFD maximum frequency.
• Make sure the VFD output frequency is correct for your spindle motor.

Spindle does not turn a low speeds

Many VFDs will not turn or have very weak torque below a certain speed.

Creating a Custom VFD Program

If there are no preexisting configurations for your VFD but you have the VFD's manual or datasheet, it's time to create a custom VFD control program.  For testing a new VFD program, the VFD must be powered on but you should not connect the spindle until the program appears to be correct.  Incorrect programming could permanently damage your VFD or spindle. Read the VFD manual carefully!

On the TOOL configuration page set tool-type to "Custom Modbus VFD". Then scroll down and begin adding VFD commands.  To add a new VFD command:

• Select the command type using the drop down menu.
• Set the address specified in the VFD's manual.
• For write operations, set the value according the the manual.

Modbus Addresses

The manual may show the addresses or values in hexadecimal so be sure to convert to decimal.

Sometimes the Modbus addresses appear in two parts.  For example: P01.05. Usually, this corresponds to a high and low byte.  In this case the address in decimal is computed as:

address = high_byte x 256 + low_byte

So for P01.05 we have:

1 x 256 + 5 = 261

Modbus Control Flow

Modbus commands are executed according to the above state diagram.  Repeated commands are executed in the order they appear. Click the green "Save" button for the commands to take affect.

Monitor the Modbus status and Active Modbus Configuration failures to see how the program progresses.  If you see failures counting up on a command that means it is failing.  The Modbus control flow is restarted after any failure.  If the very first command fails it may indicate that the communication settings don't match the VFD or the RS485 connection is wired incorrectly.

Modbus Commands

The following table defines all of the Modbus commands used to create VFD configurations with the Buildbotics controller:

Write commands write their value to the specified address.  Read commands read from the specified address and do not require a value.  Constant commands do not require an address but do require a value.

connect-write

These commands are executed once whenever the Buildbotics controller connects to the VFD.  connect-write commands are used to perform any necessary initialization.  You can enter more than one connect-write command or none at all.  They will be executed in order.

max-freq-read & max-freq-fixed

Get the maximum frequency used by the VFD. Rather than report speed, VFDs usually report the current frequency.  The Buildbotics controller needs the maximum frequency to calculate the speed.

max-freq-read reads the maximum frequency from a register in the VFD as an unsigned 16-bit integer.  max-freq-fixed does not actually query the VFD but sets a fixed value for the maximum frequency. It must match the value programmed in the VFD.

freq-set & freq-signed-set

Set the VFD's target frequency and indirectly the spindle speed. Use freq-set for VFDs that used an unsigned frequency and a separate direction setting. freq-signed-set is for VFDs which equate negative frequencies with reverse spin.

stop-write, forward-write & reverse-write

Stop the spindle or command it to spin forward or in reverse. These commands are not always required. Some VFDs use a frequency of zero for stop, positive frequency for forward and negative for reverse.

freq-read, freq-signed-read & freq-actech-read

While the VFD is running the Buildbotics controller will repeatedly read the VFD's output frequency to determine the actual spindle speed. Most VFDs use freq-read to read an unsigned 16-bit integer value, a few use freq-signed-read to read a signed 16-bit integer and ACTech VFDs use freq-actech-read to do a special multi-read.

In order to compute the spindle's actual speed, max-rpm must be set correctly and either max-freq-read or max-freq-fixed must be used to get or set the maximum frequency.  Spindle speed is calculated as:

speed = frequency / max-frequency * max-rpm

status-read

Some VFDs require regular communication to keep the connection from timing out and the VFD from automatically turning itself off.  The status-read command can be used as a heartbeat signal.  The returned value is recorded and reported on the TOOL page and in the "indicators" tab on the CONTROL page but is otherwise unused.

disconnect-write

It is not usually necessary but if there are any commands that need to be run before the VFD is disabled they can be entered as disconnect-write commands.

Sharing A New Custom VFD Program

If you have successfully created a new VFD program or need help with one you're working on, email us your controller configuration file using the following procedure:

• Click the "Save" button in the Buildbotics controller's Web interface.
• On the ADMIN page click "Backup" under the "Configuration" heading.
• Download the configuration file to your computer.
• Attach the configuration file to an email.

The Buildbotics CNC Controller provides four bipolar stepper motor drivers. It cannot drive unipolar stepper motors. Fortunately, most stepper motors can be wired up as bipolar motors.

Connecting a stepper motor to a Buildbotics CNC Controller requires properly connecting the four wires from the driver to the right wires on the motor. Unfortunately, stepper motors come in a variety of configurations and it is not always immediately obvious how to hook them up. There are several characteristics that make stepper motors different from one another. One big difference is the number of wires emanating from the motor. It is not uncommon to encounter motors with 4, 5, 6, or 8 wires coming out of the motor. This article discusses each of those configurations.

The Buildbotics CNC Controller provides four motor driver outputs through the back panel on ports labeled X, Y, Z, and A. All four of these ports are wired the same and they look like this:

Each output has four pins. The upper left pin is B+, the lower left is B-, the upper right is A-, and the lower right is A+. B- and B+ must drive one of the motor coils and A- and A+ must drive the other motor coil.

Buildbotics provides pre-made cables that connect to the driver outputs on one end. These cables are color coded such that the A+ wire is red, the A- wire is black, the B+ wire is yellow, and the B- wire is purple.

Connecting 4-wire motors

Connecting 4-wire stepper motors requires connecting A+ and A- to one of the motor coils and B+ and B- to the other motor coil.

The trick is figuring out which wires make up the coil pairs. Here’s three ways to figure this out:

1. Find the documentation for the motor. Assuming you don’t already have it, read the model number off of the motor and then search for it on the Internet. With a little effort, it is usually possible to get a datasheet for the motor. The datasheet will usually specify the wires by A+, A-, B+, and B-, or at least show which wires by color attach to which coils.
2. If you can’t find the datasheet, but have an ohmmeter, measure the resistance between any two of the motor wires. If you measure a near short, then that pair makes up one coil, and the other two wires make up the other coil. If it is an open, then measure between the first wire and another wire and then to the fourth wire until you find a near short. Notice that I say near short because the coil is a long thin wire and has some resistance. Once the pairs are identified, then arbitrarily assign one pair as “A” and  the other as “B” and arbitrarily assign one wire as “+” and the other as  “-” within each pair. Then connect the wires as shown. There is a 50% chance that the motor will turn backwards when connecting this way. If it does turn the wrong way simply reverse one (not both) of the pairs and the motor will turn the other direction.
3. If you don’t have an ohmmeter, most people can identify the pairs by feel. Stepper motor shafts turn fairly easily when the motor coils are open, but are more difficult to turn when a coil is shorted. First, leave all four motor coils open and turn the motor shaft to get a feel for how hard it is to turn. Then twist any two wires together. If the motor is significantly harder to turn, then you have shorted one of the coils and identified a pair. If not, disconnect the two wires from each other and connect a third wire to the first wire. If the motor doesn’t get harder to turn, disconnect the third wire from the first wire and connect the fourth wire. One of the combinations should be harder to turn and that is one coil and the two wires make up the other coil. Once the pairs are identified, then arbitrarily assign one pair as “A” and the other as “B” and arbitrarily assign one wire as “+” and the other as “-” within each pair. Then connect the wires as shown. There is a 50% chance that the motor will turn backwards when connecting this way. If it does turn the wrong way simply reverse one (not both) of the pairs and the motor will turn the other direction.

Connecting 5-wire motors

5-Wire  motors are strictly unipolar motors and cannot be wired as bipolar motors. As such, they are not compatible with the Buildbotics CNC Controller.

Connecting 6-wire motors

6-wire motors can be configured as either unipolar or bipolar series motors. The Buildbotics CNC Controller does not support unipolar motors. The bipolar series connections are shown here.

6-wire motors have two center-tapped coils and expose the ends of the coils and the center tapped conductor of the coil. That’s three wires for each of the two coils. The center taps are not connected and the coil ends are connected as shown. The trick is figuring out which wires belong to each coil and which of those wires are the center conductor. Here are two methods:

1. Find the documentation for the motor. Assuming you don’t already have it, read the model number off of the motor and then search for it on the Internet. You may have to call the vendor. With a little effort, it is usually possible to get a datasheet for the motor. The datasheet will usually specify the wires by A+, A-, B+, and B-, or at least show which wires by color attach to which coils.
2. Use an ohmmeter to identify the individual coils. Any wires that appear to be connected through a few ohms will be part of one coil. Wires that appear to be open are part of the different coils. Arbitrarily choose one of the coils as “A”  and the other as “B”. Once the coils have been identified, measure the resistance between each of the three wires on that coil. The resistance between the two coil ends will appear to be about twice the resistance between the either coil end and the coil center tap. When the coil ends have been identified, arbitrarily choose one of the ends to be “+” and the other to be “-” for each coil. Then connect the wires as shown. There is a 50% chance that the motor will turn backwards when connecting this way. If it does turn the wrong way simply reverse one (not both) of the pairs and the motor will turn the other direction.

Connecting 8-wire motors

Eight  wire motors can be configured as unipolar, bipolar series, or bipolar parallel motors. The Buildbotics CNC Controller does not support unipolar connections. Before configuring an 8 wire motor, you must first decide whether to configure the motor as a bipolar series or a bipolar parallel motor. Bipolar parallel connected motors will generally provide higher top speed, but will require twice as much current as a series connected motor. A series configuration should be used if the parallel configuration current exceeds the output capability of the driver. This is especially true for larger motors. In the case of the Buildbotics CNC Controller the maximum current is 6 amps for any individual motor port.

The following diagram shows the connections to be made for an 8-wire series connected bipolar stepper motor.

The next diagram shows the connections for an 8-wire parallel connected bipolar stepper motor.

It is not realistic to sort out all of the possible combinations of connections with an ohmmeter or by feel. You need the datasheet for the motor to hook it up. Assuming you don’t already have it, read the model number off of the motor and then search for it on the Internet. You may have to contact the vendor to get the motor datasheet. The datasheet will usually specify the wires by A1+, A1-, A2+, A2-, B1+, B1-,  B2+, and B2-, or something like that. Given that information, simply wire the motors as shown in the diagrams above.

1. Connect Pin 17 (spin pwm) the DB25 Breakout Board to the PWM+ input on the Spindle Controller.
2. Connect GND on the DB25 Breakout Board to PWM- on the Spindle Controller.
3. Move the jumper on the Spindle Controller to the "J21" position.
4. Connect the red wire from the Spindle to M+Load terminal on the Spindle Controller.
5. Connect the black wire on the Spindle to the M-Load terminal on the Spindle Controller.
6. Connect a V- terminal on the 48VDC power supply to the Power-In side of the AC/DC connector on the Spindle Controller.
7. Connect a V+ terminal on the 48VDC power supply to the positive side of the AC/DC connector on the Spindle Controller.
8. Connect the DB25 Breakout Board to the back of the Buildbotics Controller.
9. Connect power to the 48VDC power supply.
10. Connect the 24-48VDC power supply to the Buildbotics Controller and turn it on.

After the Buildbotics Controller boots, navigate to the "Tool Configuration" page and set the following parameters.

1. Set 'tool-type' to 'PWM Spindle'.
2. Leave 'tool-reversed' unchecked. (If the spindle turns backwards, either check this field or reverse the wires between the Spindle and the Spindle Controller.
3. Set 'max-spin' to 12000 RPM. This value varies with the type of spindle and controller, but the common spindle and controller shown should be set to 12000.
4. Set 'min-spin' to 0.
5. Set 'tool-enable-mode' to 'lo-hi'.
6. Set 'tool-direction-mode' to 'disabled'. The Spindle Controller shown does not provide reverse operation. If your Spindle and Spindle Controller do support reverse operation, connect the wire to pin 16 and set this field to the value needed for the spindle controller.
7. Leave 'pwm-inverted' unchecked.
8. Set 'pwm-min-duty' to 1
9. Set 'pwm-max-duty' to 100
10. Set 'pwm-freq' to 1000
11. Leave 'rapid-auto-off' and 'dynamic-power' unchecked. These fields are mostly used for laser engravers.