Project Vulcano

Most of my projects started with something that already existed. I redesigned it, upgraded it or made it work better.

I wanted one project for my portfolio that I could build completely from scratch and call my own. The idea, the decisions, the software, electronics and hardware.

I've been playing electronic darts since 2008. I had a Löwen FM90 at home for years. Played it, fixed it, maintained it and had it apart more times than I can count. Somewhere along the way, playing darts and messing with the machine became the same hobby.

I've played on plenty of other machines, but the FM90 is still my favourite. That thing is a tank.

So when I decided to build my own, I knew what I wanted. Better electronics, better diagnostics, modern software and easy to work on when something eventually breaks.

That's how Vulcano started.

I didn't want to buy a professional dartboard just to test the idea.

So I bought a cheap kids' dartboard, took it apart and connected the target matrix to the controller. I mapped the segments and uploaded the firmware to the controller.

I put together a basic dartR game app on the PC, connected everything and threw the first darts.

It responded exactly as I'd imagined.

Three hours later, I had my proof.

GO.

The project has been moving for a while, so I'm starting a build log.

I'll post when there's something worth showing. Cabinet work, wiring, firmware, depends what's on the bench that week.

The photos are just from the garage. I don't set anything up, so it usually looks messy.

It's been three months since the proof of concept. Most of that time I've been staring at code and drawings. Not much of it is worth a photo.

The firmware's finished now, and I've got one wiring plan instead of twenty bits of paper lying around the bench. Everything's backed up before I start testing.

The next job is to get everything working on the bench. I want to test the relay, proximity sensor, target matrix, buttons, piezo, coin acceptor and lighting one by one before any of it goes into a cabinet. The cabinet is still at the sketch stage.

First proper 3D sketch of the cabinet. You can see roughly where it's going, though a lot of it will still change.

Spent most of today going through the wiring plan again. Checked every sensor, relay and pin against it. Found a couple of things I wasn't happy with and fixed them now instead of later.

The next job is working out how the wiring will actually run through the cabinet. Once that's sketched out properly, I can stop looking at the 3D model and start building it in the garage.

The garage belongs to dartR now. Honda is out.

I didn't spend much time in the garage this time. Most of it was on the computer.

I went through the firmware, the calibration software and the documentation and fixed the small things I found. Easier to sort them out now than with the whole thing screwed together.

The workbench is in the garage now.

Hurt my hand a bit, so I'm out of the garage for a while.

I can still type.

Prepared the logo for shirt printing and made a few mockups.

Almost finished.

Then came another redesign.

Two additional panels.

The new panels are now in one place.

The current 3D design, translated into a more realistic view.

Same direction.
Now easier to see.

Started with the dartboard section.

Started assembling the base section.

Built the base support, fitted the adjustable feet and installed the coin door.

The base and dartboard sections are together. Just the top section left.

Top section coming together.

Top section mounted.

Base cabinet doors milled to 22.5°, biscuit joined and glued.

Base cabinet doors mounted.

Hinges fitted and adjusted.

I made the first TestBench to check communication between the PC, controller and hardware.

While using a car diagnostic scanner, I got another idea. Why not turn it into something similar for Vulcano?

So I built a proof of concept.

I could test the hardware manually, run an automatic test and watch the controller traffic while tracing a fault.

It worked. Now it needed some real testing.

Started with the hinges and mounted the bare door on the cabinet to see how it sits.

I marked the bullseye at the official 173 cm height.

Made a template for the router and cut the dartboard opening.

Then did the button holes the same way.

Mounted the dartboard.

Printed the button graphics and fitted the arcade buttons.

Spent the day with the controller PCB on the desk, going through it pin by pin.

Each input was triggered by hand on the controller and checked all the way through to the PC TestBench. Buttons, keys, coin input, dartboard matrix and relay all passed.

The first TestBench did its job. It proved the idea and passed the tests.

After using it for a while, I started looking at it more like the diagnostic tools I know from cars. That changed quite a few things.

So I went back and redesigned it. Different layout, different colors and a different way of working. The tests are faster now, duplicate tests are gone, and the old Auto Test has been replaced by Global Test and Manual testing.

It still does the same basic job: tell me what works and what doesn't. It just does it a lot better now.

Today I made the final changes to the controller software.

The controller used to have a few jobs to do before the game app boots. It worked, but having two masters meant more rules between the controller and the PC.

I didn't need that. The PC is the master now. The controller just passes information back and forth.

It boots with all outputs off, reports SYS:BOOT_COMPLETE and waits for commands.

Spent some time reading electronics forums and figuring out the best way to handle the piezo circuit.

Worked out the circuit, then drew the schematic in KiCad and designed the PCB from it.

Marked out the opening on masking tape and rough-cut it with a jigsaw, then cleaned up the edges with a small router until the module dropped in.

Spent more time working out where to mount the power switch module than doing the actual job. Had to think about where the mains cable would enter the cabinet and how the wiring would run from there.

Router ran all day. Ventilation slots, the speaker opening, the power inlet and every hole the wiring has to pass through.

Mounted the PC on its original bracket. Had to make a bracket for the ATX power supply.

The hardest part was working out where each module and component had to go.

With all the holes drilled through the cabinet and some of the hardware already in place, I started working out how to route the wiring. The AC and DC routes were crossing each other. Running 230V next to the controller wiring could pick up electrical noise and cause false triggers. I don't know if it would in this cabinet, but changing the routes later is more work than separating them now.

The idea was to split the cabinet into an AC side and a DC side. The main switch was already fixed in position, which determined where the AC side had to be. That left the other side for the DC and signal wiring.

The hinges were in the way. With them on the right I couldn't keep the two sides separated, so I moved them to the left.

Now the 12V, 5V and signal wiring can run through the hinge side to the dartboard door, while the 230V AC and HDMI can run up the right side to the monitor.

Drew the matrix board in KiCad. Flat cable from the target goes into a 16 pin header, controller wires onto solder pads.

Redesigned the Piezo and the Matrix PCB. Printed, ironed and etched them. They came out okay.

As the project grows, the TestBench keeps growing with it. This time I reworked the sensor section and added the tools I need for the piezos.

It now shows live levels and hit peaks for both piezo channels. I'll use the measurements to decide whether the final setup will use one or two piezo sensors, and where they should be mounted on the board.

Another day on the TestBench. Most of it went into the communication between the PC app and the controller, and into what happens when a message comes in broken or an event gets lost along the way.

The emergency stop now cuts the main lighting first. Broken serial messages are dropped, and the app shows when a measurement is not confirmed instead of a number I cannot trust.

The software side is ready. The next checks are on the actual machine.

Played around with toner transfer and an iron again. This time I used it to put the silkscreen on the top side of the Piezo PCB.

Came out better than I expected.

The TestBench got an oscilloscope. Now I can see both piezo channels live and measure the signals.

I can freeze the screen or catch a hit and keep the whole signal on the graph, not just the peak. Each hit gets its peak value.

Tested it with jumpers for now, from the controller all the way to the screen. I'm still waiting for the components to build the piezo boards.

I thought I was done with the TestBench, but after adding the oscilloscope and using it for a while, I found a few more things to fix. Mostly small stuff to make the tests quicker to use and easier to read. I also added a C1 option, so the same test can run with and without the filter capacitor.

It's ready for this phase now. Knowing me, it won't be long before I come up with something else to add.

Still waiting for the piezo components.

The components were delivered today. I didn't waste much time and got straight to work.

I tinned the copper traces and left the red copper layer only on the letter R in the logo on each board. I really like how it looks.

C1 is still empty. There's a spot on each board for a small 470 pF to 1 nF C0G/NP0 capacitor between the signal going to the controller and GND.

Together with the 10 kΩ series resistor it makes a low-pass RC filter, with the cutoff somewhere around 16 to 34 kHz depending on the capacitor value. The piezo disc rings at about 2.6 kHz, so the hit signal goes through without a problem. The filter would only cut very fast spikes and noise the cable can pick up from relays or lights. It should also make the controller's analog readings a bit steadier.

I haven't soldered it because I don't know yet if it's needed. If there's no noise, the filter can only hurt. It rounds off the short peaks a little, so a weaker hit might not register. The TestBench already has the C1 option, so I'll compare the signal with and without it. If I get false triggers or jumpy readings, I'll add C1 and pick the value based on the results.

The Matrix PCB is in the cabinet. The hardest part was deciding where the board goes and how to mount it. Once that was settled, the rest followed.

The flat cable from the matrix plugs straight into the board. From there the matrix lines run to the controller through a ferrite core, red for columns, black for rows.

I was just thinking I'm getting close to plugging the dart machine into 230 V, and now there's another PCB on the list.

I ordered the PCA9685 and ULN2803 modules a while ago. As soon as they arrived, I rushed to solder the green screw terminals on. That turned out to be a mistake.

After mounting the Matrix PCB today, I started looking for a place for the lamp driver modules. That's when I realized how many wires I'd end up with. It was going to be a mess.

So instead of mounting the modules separately, I decided to make a carrier board for them. I drew it in KiCad, with the modules plugging straight into sockets and all 16 outputs going to one terminal block.

Now those green terminals have to come off again. Pin headers are going on instead.

The concept sketch is there in KiCad, but it still needs a few corrections.

I was uploading the Vulcano photos to cPanel and going through them to decide which ones to use in the Build Log. In a few of them my old multimeter was in the frame, and I noticed it wasn't the cleanest thing on the bench.

My first thought was, I'm not putting that on the website. So I used the photos where it wasn't in focus.

Later I thought, why hide it?

I've had this multimeter since 2004. I bought it while I was at Ruđer Bošković Technical School, when I was building a car alarm for my graduation project.

It stayed with me after that, through all my hobby projects: installing car multimedia, woofers and amplifiers, xenon lights, fade-out interior lights, footwell and ambient lighting, alarms, central and remote locking, remote engine start, follow-me-home lights...

Then there were engine swaps, injection and ECU wiring, repinning OBD connectors and modifying wiring harnesses...

Through all of that, it was always there, ready to beep when I needed to find the right wire.

Sticky fingers from electrical tape, dirty hands from stripping wires, engine oil and dust from under the hood had done their part over the years.

Today I gave it a proper clean and took another photo. This time I'm leaving it in the frame.

I ran the wires to the arcade buttons, crimped the terminals onto the microswitches and LED lamp holders, and started laying them out.

Once that was done, the wiring around the Matrix PCB started bothering me a bit. It would have worked as it was, but it could be cleaner.

I replaced the regular electrical tape with the fabric tape used in cars to stop wiring from rattling behind the panels. I also swapped the white self-adhesive cable tie mounts for black ones, tightened the wiring up a little and reorganized the routes with mini cable ties.

The wires going toward the controller and the future carrier board are left long for now. Once the carrier board is in, I'll cut them to length and route them properly.

Most of the day went into the carrier board again. KiCad doesn't have footprints for the PCA and ULN modules, so I made my own and kept adjusting them until they matched the real boards 1:1. To check, I printed the silkscreen on A4 paper and laid the PCA and ULN boards on top. Every hole lines up now.

New labels went on the silkscreen, and I tidied up the traces on the copper side.

The green screw terminals are off the modules now, with pin headers going in their place.

Everything else is here too: PCB material, etching chemicals, headers and green connectors. Next comes the iron transfer and etching.

The plan for today was to make the carrier PCB.

I opened KiCad and generated the PDF for the silkscreen print. Looking at it, I thought there was plenty of space for some graphics and that the board could use a bit more character.

So I put the PCB build on hold and spent the next two hours redesigning the graphics.

This was the result.

Printed the layout, transferred it to the copper and etched the board.

Drilled the board, soldered the headers and connectors, and finished the carrier PCB.

Plugged all the ULN modules and the PCA into the carrier board.