Archive for the 'Uncategorized' Category

DrawBot Badge – Preview

I showed off an early version of my DrawBot Badge at the Hardware Happy Hour last night. Some tweeted pictures generated a lot of questions, so I thought I would write a quick post about it.

I have been following the #badgelife thing for a few years and felt that the mechanical and CNC world needed to be represented. The goal was to create something small, safe, fun and something anyone could learn to use. A drawing machine seemed the perfect fit.

Drawing Surface

I decided to use 3″ square Post-It notes. The main feature is that they are self stick, so I don’t need any clamps or tape. It is also cool that you can stick them to things when the drawing is done. They are cheap and easy to find. I like the kind that have the majority of the back (full stick) covered in adhesive. This means you can use a small stack of them and peel them off as they are done.

 

Drawing Mechanism

I tried to make the drawing mechanism as tiny as possible. The size is about 30mm x 70mm. It uses (3) of the smallest readily available class of hobby servos call micro servos. You can buy these from AliExpress for as low $1-$2 in low quantities.  The choice of the arm configurations was primarily based on tightly packing the the motors, but I also wanted something new and interesting.

The pen lift is simply a cam on one of the motors. The entire mechanism rotates on two 3mm bearings. In my experience with drawing machines, gravity is the best way to engage the pen to the work. The mechanism needed to work hanging from a lanyard or sitting on a table.

Electronics

There is only one electronic item right now. It is an ESP32 dev module. There are also (3) connectors for the servos and (1) for voltage monitoring. The entire back of the badge is a PCB. I made the board full size to enclose the back and the pen lift cam need to push on something. I have big plans for the rest of the area though. The ESP32 provides the Bluetooth and Wifi needed for the remote control.

Firmware

It is running my ESP32 port of Grbl with a little hacking for the servos. The ESP32 uses an RTOS, so I just created a low priority, repeating task (20Hz). The task checks the position of a virtual CNC machine, does some kinematic math and updates the servos. The software supports streaming drawing data (gcode) via serial port, bluetooth, SD card or wifi. I am using the bluetooth option to send via my phone. I will publish the firmware soon.

Crazy Math (Kinematics)

The math is actually not too hard. You know the desired pen location, the axes of the servos and the lengths of the linkages. There are two ways to do the math. The first way is using the law of cosines and the Pythagorean theorem.

The second method uses intersecting circles. Each linkage can sweep a circle from a axis point and radius. Any two linkage’s circles will intersect at two points. It is easy to pick one of the points as more desirable. While it is less deterministic, due to the two points thing, it appears to run about 40% faster on the ESP32.

The Z is very simple. Any Z value less than 0 is pen down and everything else is pen up.

Drawing Quality

The quality is basically “Adorably Wiggly”. I am using the cheapest analog servos. That means I might get about 200 x 200 resolution at best at the servo hubs. If you mapped that grid to the paper it would be a warped grid with dense and sparse areas of the grid due to the non-linear nature of the mechanism. Digital servos with very low deadbands (~1us) it would probably do a lot better, but I am not sure that is worth it. It would only be a little less wiggly. They cost about 4x what analog servos do (still pretty cheap).

There is a calibration feature. Each servo is a little different and it is difficult to precisely mount the arms at the right angle. The calibration adjusts the zero angle and pwm/degree of rotation.

Next Steps

This project is part of a talk proposal for Hackaday SuperCon 2018. If that gets accepted, the badge will become a full featured CNC controller capable of running a router, laser cutters, high res plotter, etc, as well as the Drawbot badge. Only the DrawBot will be populated. The rest will be modular like this board.

I may also make a simple version that is only the draw bot. The BOM cost is currently about $10-$12 (without 3D printed parts)

Regardless of what happens all source files will be publish sometime in October.

 

Follow me on Twitter (@buildlog) or subscribe to this blog if you want to follow the project.

 


If you want to be notified of future blog posts, please subscribe.

 

 

 

 

 

 

 

Grbl_ESP32 Development Board Instructions

Overview

These are the basic instructions for setting up and using the Grbl_ESP32 CNC board. This is an open source CNC controller. It is for sale on Tindie. The source files are located here.

Program the ESP32

It is always best to program a CPU for the first time not mounted to a board. You don’t know if the current firmware will cause harm in the new application. A simple blink program could damage an I/O pin if that pin is tied to ground or a voltage when mounted.

Setup the Arduino IDE

  1. Get the latest Arduino IDE from arduino.cc. (important…the latest)
  2. Install the Arduino Core for ESP32 by following instructions here.
  3. Using the board manager and other tools menus select the board you have (see below for what options to set.)
  4. Download the Grbl_ESP32 firmware from the GitHub repo. The master branch is generally more stable, but other branches will have the latest features.
  5. Connect the ESP32 board to your computer via USB
  6. Select the com port associated with the ESP32 module you have
  7. Compile and upload the code.

Configure Grbl_ESP32

Now that you know you have everything setup properly to program the ESP32, it is time to configure Grbl. There are only (2) files that typically need to be edited. The defaults should work in many cases, but it is good to know what options you have.

  • cpu_map.h – This is the file that tells the firmware how the I/O pins should be used. The defaults will work with this board without changes.
  • config.h –  This has dozens of things you can change. The defaults will work, but other features may interest you. There are lots of comments in the file to help you understand them.

If you made any changes, compile and upload the code again.

Install the modules into the controller board

  • ESP32
    • Disconnect the USB and install the ESP32. Be sure the USB is aligned with the edge of the board and the pins are perfectly aligned with the holes.
  • Motor Drivers (DRV8825 Recommended)
    • Make sure they are installed correctly. (2) of the pins are labeled, match them up with the same labels on the drivers
    • Set your micro stepping level according to the driver specifications. (DRV8825) using the jumpers provided. The jumpers are labeled (1,2,3  to correspond with the labels on the drivers. See image below)
    • Temporarily connect power (12VDC to 24VDC) to the board and set the current for the drivers. See the driver specifications on how to do that. They work well up to 1A without active cooling. They are set much higher by default and will generally have problems, so you should adjust them
  • SD Card
    • Install the SD module. Align the pin labels with the module and controller board. Note: The controller board has vcc labeled as 3.3V. It is actually 5V.

[image – Microstep jumpers]

Connect your motors, switches, etc.

If you need connectors, I recommend this set. It is low cost and will cover many projects. You can crimp the pins with needle nose pliers, but a crimping tool makes faster and better crimps.

  • Motors
    • The motor coils are connected to adjacent pins. A typical (but not always) motor wire color order would be red – blue – black – green.
  • Limit/Home Switches
    • Wire these as normally open and close to ground. Each switch has its own ground connection on the board to make things easier.
  • Control Switches
    • They wire the same as the limit switches, except the door should be a normally closed to ground. The door pins are connected with a jumper by default for people that don’t use the door feature.
  • Spindle
    • The Spindle PWM controls your spindle speed. If you want to run an on/off rather than variable speed spindle, just change the max RPM to 1. This means any RPM value with be full on. This is done via the $30=1 command. Note: Never connect these pins directly to a spindle or relay (non solid state). It is a very low current 3.3V TTL signal that must be connected to a speed control device or TTL relay driver.
    • Spindle Enable & Direction – This is not supported at this time, The I/O pin is used for the SD on the default firmware.
  • Flood Coolant – This is a 3.3V TTL signal to control a relay via the M8 command
  • Mist Coolant – This is not supported in the default configuration. The I/O pin is used for the SD card on the default firmware.

Power up, test and tune.

  • Get a gcode sender – Here is a good list of senders
  • Many of the settings can be adjusted with $ settings. You can see what the codes mean here.  Send $$ to see the current values. Send $xxx=xxx to change one.
  • Motor Direction – Try jogging the motors. If they go the wrong way your can either spin the connectors 180° or adjust the $3 value in the $$ menu. You should always remove the power if you disconnect motors. The drivers can be damaged if connected while power is on.
  • Tuning motor speed – By adjusting motor acceleration you can see how fast your motors can go with your setup. I like to see how fast the can go unloaded and then use about 75% of those values.
  • Homing (optional, but highly recommended)- Enable homing with $22=1. Switches can be put at either end of travel. Try homing. If any axis does not move towards the switch, you can switch the homing direction with $23

Places to get help

F.A.Q

  • Coming soon.

 

 

Grbl_ESP32 CNC Development Board

This is development board for using CNC on Grbl ESP32. It supports all of the current and planned features of Grbl_ESP32. It is a great way to get started with the firmware.  It is currently for sale in my Tindie shop.

ESP32 brings the following benefits Grbl

  • Small and very low cost
  • Powerful dual core processor running at 240MHz per core
  • 4MB of flash RAM
  • Floating point coprocessor
  • On board Wifi
  • On Board Bluetooth

Features

  • A very modular design – If any of the major circuits get damaged, you can plug in a new one.
  • A socket for a ESP32 Dev board also known as NodeMCU 32S. Most 19 pin per side dev boards should work, just check the pins or ask me.
  • (3) Sockets for stepper motor drivers. These fit many types of drivers. The TI DRV8825 type is my favorite driver for this type of application. Micro-step selection jumpers are included.
  • Home/Limit switch connections for XY and Z axes. These also have R/C filters to eliminate high frequency noise from false triggering the switches.
  • Z Probe connections with R/C filter
  • Control switch input connections for Feed Hold, Cycle Start, Reset and Door. These have filters as well as pullup resistors, because they are on inputs that do not have internal pullups.
  • Spindle output for PWM (Speed). Spindle Enable and Direction are also connected, but not in firmware yet.
  • A socket for a micro SD card module. Note: The SD card feature is in testing and not in the master branch firmware yet. Also it shares pins with other non-popular features that would have to be turned off (Mist Coolant, Spindle Direction and Spindle Enable)
  • DC-DC power supply. There is a strong 3A DC-DC power supply to run the ESP32 if it is not connected to USB. It is adjustable, 0.8V to 20V, but would typically be set to 5V. It also has connections, for off board use.

Required Modules

What it Comes With

  • Fully soldered based board.
  • DC-DC P/S installed and adjusted
  • Basic Testing and Inspection (Voltages  and components)

Open Source

The design is open source with Creative Commons 4.0 Attribution – Share Alike . Here are the source files.

Errata

  • The SD Card pin 5 (vcc) was accidentally hooked up to 3.3V. It should be connected to 5V. The boards have a simple cut and jump. Keep this in mind if you use the gerber files.

Where to get one

You can build your own from the source files or you can buy one from my Tindie store. Buying one from me helps support this project.


If you want to be notified of future blog posts, please subscribe.

 

Grbl_ESP32 update: SD Card Support

Here is a look at something I have been working on. I have added some SD card features to Grbl_ESP32.

Why SD Cards?

Grbl works great with senders and really shouldn’t need SD card support. That is true for your typical desktop CNC router. laser, etc., but there are a lot of machines that are not “typical”. I like to make machines I can fit in my backpack or in the palm of my hand. I certainly don’t want to use a traditional PC – Machine setup. I want control via phone or completely autonomous. This means SD card, Bluetooth and Wifi options are critical.

Does a machine even need connectivity at all? Running a file from an SD card and uploading new firmware via SD card is going to be critical for some new projects I have plans for.

What is the best way to do this?

After debating a few methods of implementing this, I decided to do it in a more Grbl’y way, than a Marlin’y way so that it is less likely to break the existing Grbl gcode senders. This means I’ll try to report status and push notifications in a way that won’t break anything. I’ll also follow the strict NIST gcode rules of Grbl. NIST does not have SD gcodes, so they will be more like Grbls $H (homing) than Marlins equivalent gcodes.

With that said, if anyone has some suggestions for changes, I am still in a stage where I can consider them.

Protocol

The commands all start with $F (for file).

  • $FM – Mounts the SD card. You do this once whenever you want to use the SD card or after you re-insert.
  • $F – Reports all the files matching (.NC, .TXT or .GCODE). It printrs one line per file like [FILE:/myfile.nc SIZE:7609]
  • $F=/myfile.nc – This runs the file.

Job progress is automatically appended to the end of the “?” command response. like <…….|SD:55.78> where 55.78 is the percent complete.

Sender Compatibility

  • All of senders I have tested (UGS, LaserGrbl, Grbl Controller) are OK with these changes.
  • They continue to request and get status and update the DROs.
  • If they have a verbose option, you can see the job progress.
  • Some (Grbl controller) filter out (don’t display) the [FILE:….] responses even on verbose mode.
  • All can be disconnected during a job without affecting it.
  • Most send a Grbl Reset when reconnected which kills the job. This would be easy to ignore during SD card jobs (not implemented).

Next Steps

  • I will release a branch with these features
  • I want to look at adding a card detect feature to auto mount the card
  • Look at methods of firmware upgrade via SD card.
  • Can a file be uploaded to the SD card (USB, Bluetooth, Wifi)?

Video


If you want to be notified of future blog posts, please subscribe.

 

Grbl for ESP32 Beta Release

Grbl for ESP32 Firmware Beta

After a lot of work and testing, I have posted the firmware to GitHub. I have a good write-up on the process I went through to get to this point on this blog post. There are some basic getting started instructions on the GitHub page. Realistically, this probably should not be your first Grbl or ESP32 project, but go ahead if you like.

If you want to keep up to date on the project, subscribe to this blog (see end of blog), subscribe to my YouTube channel or follow me on Twitter (most frequent updates). Comments, thumbs up, retweets and replies are very much appreciated and keep me going.

If you see any issues, please comment here or at GitHub. GitHub is preferred for firmware issue tracking.

BTW: If you are interesting the test controller I made, here is a schematic.

Next Steps

I have a busy couple of weeks coming up with some friends coming from France to visit. I won’t be able to work on the project much. The first thing I want to add when I get a chance is BlueTooth support. If you know of any similar projects streaming text from a phone or PC to ESP32 over Bluetooth, please let me know.

Video


If you want to be notified of future blog posts, please subscribe.

Grbl CNC Firmware on ESP32

Woot!

I have been working on this for months. I am happy to announce that it is finally working right. The ESP32 will be a great option for CNC. Here are some things I am excited about.

  • Fast – Two 32 bit Cores at 240MHz Each, FPU, 80MHz Timers
  • Memory – Tons of Flash and RAM
  • Low Cost – $3-$10 depending how you buy it.
  • Small Size – Not much bigger than an Arduino Nano
  • I/O – It has about the same number of pins as an Arduino UNO, which is the target for Grbl
  • BlueTooth and WiFi – This is great and actually the primary reason for my port.

Porting

The bulk of the code was very easy to port over, but getting very low jitter, step pulse timing took a long time to achieve. This is not my first port of Grbl. My first port was to the PSoC5. That was much easier, but this was my first major project on the ESP32.

A goal was to use the Arduino IDE to develop the code. I thought it would make the project a lot more accessible to novice programmers that just need to make a few tweaks. I also tried to make the code easy to maintain with Grbl. This means there a few throwbacks/workarounds to AVR port numbering. etc.

FreeRTOS

The ESP32 uses an RTOS (Real Time Operating System). While “real time” sounds perfect for CNC, it is not good for step pulse timing. An RTOS allows multiple tasks to run “at the same time” and it manages the priorities and interaction of those tasks. The RTOS switches tasks at a “tick rate”. The tick rate is typically about 1000Hz. This means each task gets at least 1ms of time and the others wait. You can designate a high priority task to prevent these interruptions, but some tasks have watchdogs that must be reset so you need to give them some time.  You can set the tick rate higher, but I need a more than 50,000 hz step rate. That is not practical for the RTOS. I can turn off the RTOS and/or the watchdogs, but a major appeal of the ESP32 is the WiFi and BlueTooth. These need the RTOS.

Interrupts

The normal Grbl way generate step pulse timing is to use interrupts. As long as you follow the rules for interrupts, they will interrupt the RTOS without any delays in very deterministic manner. The rules are about how much time you can spend in the interrupt and what things you can do in the interrupt. The interrupt duration was not an issue because the code in the interrupt only takes a few micro seconds. What you can do in the interrupt took a while to figure out. The ESP32 does a “panic” reboot when it does not like something. That happened a lot during development. Most of my problems were related to how I used the peripherals. Things like the RMT feature simply can’t be used.

My Dev Board

I designed a little Dev Board to help me with this project. The features include…

  • 3 Stepper Drivers
  • 3 Limit Switches
  • 1 Touch Probe connector
  • Mist / Flood Coolant outputs
  • Start / Hold / Reset / Door switch connector.
  • Spindle / Servo / Laser – Connector
  • SD Card – This is just a breakout to a header that can be wired into the CPU if I ever decide to do that.

Next Steps

Testing – I need to do a lot of testing. I tested most of the features along the way, but need to double check all the config options.

Clean up – I have a lot of commented out debug code that needs to be removed

Publish on GitHub – Done. GitHub Repo

BlueTooth – That is the first new feature I want to add.

Hobby Servo Features – I use them a lot in my small machines and 328P Grbl doesn’t handle them well because the lack of 16 bit timer availability. I want high resolution jitter free servos as an option for any axis.

Simple Kinematics – GCode can be converted on the fly to alternate coordinate systems. This would not consider joint dynamics.

Video


If you want to be notified of future blog posts, please subscribe.

PSoC5 Grbl with Native USB

I added native USB support to my PS0C5 port of Grbl. The PSoC has USB capability on the chip. It also has a component for using it as a USB UART (CDC Interface). This means it looks like a serial port to the connected PC and uses the standard CDC interface driver that most OS have.

I am currently only using this on the PSoC5 development board so I am comfortable using their VID and PID values. If I make some custom hardware and distribute it, I will need to get my own.

Advantages

  • Low Cost – You don’t need to buy a separate USB/TTL chip
  • Faster – It should be able to run a lot faster. You can select any baud rate you want. It never converts to TTL I think the rate is meaningless. I am not sure if it translates to actual fast jobs, but it might on data heavy laser type jobs where the laser power level is changing a lot.
  • Compatibility – It still looks like a UART to senders, so you can use all existing senders.
  • Future Features – It might be possible to have the USB look like multiple features like a memory device, to make file transfers possible.

The Code

I put it in a separate repo from my last code. I started with a more recent version of Grbl, plus I removed the LCD code. I typically don’t use the LCD and prefer a serial/bluetooth remote. It could be easily added back in from the original port.

To do list?

  1. The USB is checked for incoming data in the protocol_main_loop(). Is there a way to do this with an interrupt?
  2. Arduinos have a DTR triggered reboot. Some senders expect this. Can we emulate this behavior?
  3. I want to add SD card support to Grbl
    • Then try to make that accessible as a USB drive.

Help?

If you want to help, just let me know via comments below or on the GitHub page.

 


If you want to be notified of future blog posts, please subscribe.

 

NickelBot Updates

The NickelBot has been running great, but there were a few features I also wanted to add. I made a rev 2 PCB to address them.

Laser Door Interlock

There is a door switch that cuts power to the laser. I did this by splicing into the 12V power line going to the laser. I thought that was an effective, but ugly hack. There is now a dedicated connector for that switch.

Fan Control

On rev 1, the fans run continuously. This reduces my run time, when I run off a battery. I added a FET to control the fan power. I want the fans to turn on whenever the laser fires and stay on for a few seconds after the last pulse. Since the controller is a PSoC, I was able to implement this as a custom hardware peripheral. I used my pulse extender component.

Here is the schematic. The trigger is connected to the PWM signal going to the laser (labeled spindle). There is a 16 hz clock that is used to count down a short delay after the last pulse.

BlueTooth

Using a connected computer sort of spoils the coolness of these tiny machines. Using a phone and BlueTooth is way cooler.

Most of my other tiny CNC machines use BlueTooth. I don’t know why I forgot it this time. It is the first time using an HC-05/HC-06 bluetooth adapter with PSoC, so that might be the reason. I decided to use a second UART, so I could use both USB/Serial and Bluetooth at the same time.  The changes to firmware where pretty trivial.

Grbl Controller Shout Out

The main Android phone app I use is Grbl Controller. It really works great and is so easy to use. It works great with the cheap HC-05/HC-06 BlueTooth adapters. I just send gcode files to my phone and run them from there. I can even turn the phone “off” and stream from my pocket.



If you want to be notified of future blog posts, please subscribe.

 

NickelBot – Complete

The NickelBot is complete and it works great. The goal of the project was to create an easily portable machine that creates low cost items that could be given away at events like Maker Faires. I think it has completely achieved that goal. The nickels are purchased from Amazon and cost about $0.08 each.

Here is a video that explains the machine.

Results

It is quite reliable and the cycle time is is just about right at 1-2 minutes per nickel. I think the engraving quality is quite good. I ran it at the Chicago Northside Maker Faire last weekend. It made about 60 nickels without any problems. Here are some of the nickels it made.

Mechatronics

The NickelBot uses (2) NEMA14 stepper motors in a T-Bot configuration. These drive a single GT2 6mm belt. The linear bearings are (2) 6mm rods per axis with (1) LM6LUU per rod.

To handle the nickel loading and unloading, it uses a single micro hobby servo. This servo  connects via a 0.03″ brass wire to a clamp. The firmware has (3) positions hard coded for the servo for fully open, nickel support only and supported plus clamped.

All 3D printed parts are PLA printed on a Lulzbot TAZ6. The colors just represent the color that happened to be in the printer at the time.

The Laser Module

The laser module is a 3.5W peak, 450nm (blue) laser. It comes with a laser power supply that has a 12V power input and TTL laser control input. It also comes with a 12V 5A power supply. I bought it a few months ago from Banggood.com when it was on sale for about $70, but they are typically around $99.  I control the engraving power with a 5kHZ PWM from the microcontroller.

Controller

I used a PSoC5 development board as a plug in on a custom PCB.  I knew adding an additional, accurate PWM for the servo was going to be vastly easier on the PSoC5 vs. an Arduino.

This dev board has a built in programmer debugger that makes firmware development very easy. It is great to be able to set breakpoints and check values with the debugger. I have have a another blog post with more details on this here.

Firmware

The firmware is a modified version of my PSoC5 Grbl port. The only modification needed was the code to handle the clamp servo. Rather than adding special gcodes for the clamp, I simply re-coded the M7,M8 and M9 coolant commands. I did this because all of the parsing and protocol issues were already done.  Each command represents one of the clamp positions.

I may post the source code on Github soon.

Calibration

The machine has (2) home switches (X and Y). A homing sequence needs to be run each time you power up the machine.  All other locations are referenced to this location. A one time  calibration is done to locate the following locations.

  • G54: G54 is the the default work offset. I decided to use the center of the nickel as the 0,0. I jogged the machine visually until the nickel looked centered. I then set the G54 location with this gcode line”G20 L10 P0 X0 Y0″. I made a target shaped graphic that I used to test engrave this location(see above). I used a caliper to measure the centering error, jogged that amount and reset the 0,0. I did this about 5 times until I was satisfied with the centering.
  • G28: I used the G28 location as the location under the nickel hopper. You jog to the location and set it with “G28.1”.
  • G30: I used the G30 location as the position over the eject chute. This is set with the G30.1 gcode command.

Software

I am using LaserGRBL.

This is a great program for this application. It does everything, starting with a bitmap image, to gcode sending in one application. It also has some macro (multi-line gcode) buttons that are very handy. The only drawback for some is that it is Windows only.

Here is an example of the macro to get the nickel.

G90G0X0Y0 ; rapid move to absolute 0,0
M9 ; loosen clamp
G28 ; move under nickels
G4 P0.75 ; wait for nickel to fall and settle
M7 ; close clamp
G4 P0.5; wait a bit
G0X0Y0 ; return to 0,0

Source Files

Possible Improvements

  • Interlock switch: Right now there is no interlock switch for the door. If I make a new PCB, I will add a provision for that. I’ll probably just break all power to the laser module.
  • Nickel Flip: Right now the nickel always comes out of the chute upside down. This is not the best presentation. This was a compromise to make the machine as small as possible. The nickel has to fall between the Y rods. Rather than makethe distance between the rods wider than the nickel, I designed and aligned the clamp/support system so that one side of the nickel falls first and goes between the rods closer to vertical.  There is a probably a way to design the chute to catch the nickel before flips over completely or re-flips it back.
  • Software:
    • More automation: LaserGRBL has macro buttons for the nickel feed and eject features, but it would be nice if that was automatic. They have added a gcode header and footer feature to the roadmap. Right now you can generate the gcode, save the file and paste the nickel handling code in an editor. That file is then fully automatic.
    • Customizing: It would have been fun to easily add names, etc to nickels for people.

If you want to be notified of future blog posts, please subscribe.

NickelBot – Laser Controller

Here are some details on the custom laser controller I made for the NickelBot, wooden nickel engraving machine.

I want to use Grbl to control the machine. Grbl has support for lasers that allows better power control during the engrave. It also has the Core XY support I need for the H-bot mechanism it uses. The only feature I needed that it did not have is a hobby servo output.

A hobby servo requires a PWM signal. Normal Grbl runs on a ATMega328p cpu (Arduino UNO). The 328p has 3 timers that can be used to generate PWM signals. Grbl uses all 3 of them. You can attach more than PWM output to a timer, but the only timers that would work are only 8 bit timers. That is not going to give me the resolution I want.

A hobby servo uses a 1ms to 2ms pulse that repeats every 20ms. This means you are only using 1/20th of the duty cycle range. 1/20th of an 8bit signal is pretty rough. I could have used an Arduino Mega to get some more free timers, but I did not want to deal with the physical the size of a Mega.

My solution was to use a PSoC5. I have already ported Grbl to it and it has plenty of high resolution PWM components. I used the following PWM configuration…

  • 16-Bit resolution
  • 1 MHz Timer
  • 20000 for the period (=20ms)
  • 1000 to 2000 and my compare value range (1ms to 2ms)

This gives me a resolution of 1000 or 0.18° (exceeds servo’s capability)

Here is an image of the raw PCB.

Here are the features of the PCB

  • Has a socket for a CY8CKIT-059 PSoC5 development board (only $10-$15). The only drawback is the wiggly printed USB connector.
  • 1A 5V power supply for servo
  • (2) Sockets for Pololu footprint stepper drivers.
  • (2) 12V fan connectors
  • Servo connector
  • Homing switch connector
  • Laser connector (power and PWM)
  • (2) general purpose I/O for buttons, etc
  • Extra 5V power access connector.

Source Files.

Status

The board is fully tested and 100% functional. I have it hooked up the the machine and have tested the following.

  • Home switches
  • CoreXY motor control
  • Servo control
  • Laser PWM.
  • Fans

Suggested Changes

  • The control signal on the laser supply appears to turn on the laser if left open. Therefore if the controller is not powered or actively driving the pin low, the laser will fire. That is not good. I have not tested a solution, but I think a resistor of 2k-5k Ohm pulling the pin to ground will keep the beam off when not driven low. It should be quite easy to solder this resistor between the laser pulse pin and the adjacent ground pin.

 

 


If you want to be notified of future blog posts, please subscribe.