Schematics now in Google code repository

I threw the schematics/board layouts for Disaster in the repository tonight.   That includes the input board, solenoid board, LED driver board, RS232 interface board, and a little LED board.  The previous schematic was a mashup of multiple copies of each of the boards to do a whole machine in on a single board.  The Kicad projects now have the individual boards that were copied to make the mashup.  The main controller and power supply are not in the repositories because they are not tested yet.   I know of a couple issues with the main controller board, so since it might not even be part of the final Disaster machine, I have left it out.  The power supply has been left out because I’m not sure it can produce enough current.  I’m also considering a simpler buck boost design from a 12V source.  That might be a cleaner implementation.

I updated the Java project so that it is constantly reading the hardware boards and kicking out their status bits.  Java currently reads each of the boards every 15ms.  That should be plenty fast for any pinball machine because all the real-time stuff is self-contained on the individual cards.  The actually timing will probably be slowed down to every 50ms or something a little more reasonable.

I have not implemented code for the LED driver board yet because I have made the parallel port to 4 pin header.  I’m probably just going to bit bang it since I only need to update the interface about once every 100ms to get the lights to blink at the proper speed.

That’s probably it for this week.  Lot’s of progress, and I finally got around to putting stuff in the repository which should have been there for months.  How open source hardware is it if I don’t actually have the hardware in the repository?  I apologize for complaining about the Google repository.  Tonight it is running much faster than it was Tuesday night.

First version of Disaster java application in repository

Got some time to work on the Java application that will control Disaster.  It will stream video, and eventually run all of the rules for the pinball machine.  Currently it is simply a framework with the windows set to the correct size for the display.  Depending on the parameters that are passed to the applet, it will come up as either full screen or slightly smaller for debugging.  A short HD video plays in the background once to make sure that video playback is working.  The serial port is being used to poll the cards to continuously read the inputs.  I will eventually create a debug frame (essentially the switch screen on newer pinball machines) where the switch states will be displayed in real time.

The video is rather large, about 22MB, so if you download the code, you will notice that it is much larger now.   Google code has a relatively slow download speed so it takes a while.

None of the packaging to make it easy to install on a windows machine or a linux machine has been done yet.  It currently only runs on windows boxes.  To run it, the VLC_PLUGIN_PATH needs to be set to the correct directory in your environment variables.  I will hopefully get a little bit more code done this week, but it might take me until next week to get more stuff done.

The pinball control state machine is the next big piece that needs to be done, and that is going to take me a couple of days or a week to code.  That will be the next big exciting step.

Display Controller Populated

The first display controller is populated by Mark this weekend.  This is the board that will replace the display controller board.  As you can see, it only has four digits because the other two digits weren’t used.  This is also the only display that will have a micro-controller.  All the other displays are simple i2c slave devices with three 16 bit registers each.  The jumpers for configuring it as the master display or a player scoring display are on the right side.  The connectors on the right are for powering the slave displays.

Here is a picture of the back of the of the board.  The voltage regulator/potentiometer allows the brightness of the LEDs to be changed on a system wide basis.  The processor is the largest chip on the right, and the two small chips are muxes since the processors doesn’t have enough I/O pins.  Only two of the i2c registers are populated since there are only four digits.

We were probably going to bring up this board on pinball night, but Mark now has the flu, so he is probably out for the week.  It should be relatively easy to bring up this card and test it over the next few weeks.  As soon as this card is up and running, we will build the other four player score cards (which use the same PCB) and we should be done with this project.  I’m thinking of making a little wiring harness to make the testing a little bit easier.  (Basically a connector with a bunch of pullups/pulldowns so I can simulate the pinball machine sending two characters at a time to this card.  I originally thought of doing it using the PCs parallel port, but since there aren’t enough data pins (only about 10 easily accessible), it seems easier to simply make a plug header and move the jumpers by hand.

I’ll probably end up with another entry this week on finishing the initial layout for the Disaster LCD.  It is currently streaming video while displaying four players scores.  More on that when I finish it up and get to a good stopping place to put it in the repository.  I’ve also promised myself that I will throw up the Disaster individual board schematics for the three cards that I have fully tested.

It is rather humorous to read comments about how the blog is centered around restoring pinball machines.  I imagine the blog is broken into two different sections:  restoration, and then Disaster which is hopefully going to be a pinball machine completely from scratch.  While the boards for Disaster are not the most whizz bang designs using the fastest processors, each of the processors is more powerful than the processors that are running pinball machines through the late ’90s.

Display boards received

Display Boards:

Display driver boards came in yesterday.  Here is a picture of two of the five showing both sides.  The Gerbers were sent to ITeadStudio on 12/5/2013, so it was about a one month turn.  That speed was choosing the slowest/cheapest shipping method.  Unfortunately, we haven’t ordered the chips yet.  That order will go in tomorrow and will end up taking another week to get the chips.  I’ve identified slightly less expensive displays which might bring the price of the build down slightly.  I’m looking forward to getting this built up, and then doing the testing on the firmware.  I should have gotten ITeadStudio to do the cutouts for the connectors, but originally I thought I could toss another project on the extra space, but there just wasn’t enough room.

Distaster info:  Lately I’ve started the Java framework for running the pinball controller.  I tossed CodeDownload into the repository (actually that will happen tomorrow) so the solenoid driver and input driver firmware can be updated without a debugger.  It is a windows application, but could easily be modified to work on a Linux box by changing some small things with serial port naming conventions.

I’m planning on making a parallel port bit banged fake SPI interface so that I can test the LED driver.  That should be very simple and should give me enough pieces to make the first “fake” pinball machine.  Basically a pinball machine with my boards giving the inputs states to a PC, and the PC showing how the pinball machine would react.  I’ll attach LEDs to the solenoid drivers to show when the solenoids are on.  That is probably going to take a good bit of coding to make that happen but it is a good next step.

I finished my design for a boost converter to try and get 50V from a 12V source, so I will be trying to “bread-board” that and see how it works.  That was an extra piece of work that I wasn’t expecting, so I might put that off for a little bit.  It seems like it is a much cleaner solution than my original solution of bridge rectifier to buck converter.