Roland JV-30 Garage Sale Find and Restoration

This Roland JV-30 16 part multi timbral synthesizer was purchased at a garage sale for $5.

No power supply was included, it requires 9V 800mA (at least) on a center negative barrel connector. To test the unit a new barrel connector was used with the current limited DC power supply set to 9V.

No life.
Yikes! current clamped, 1.55A at .7V!

Time to look inside. Someone’s been in here before, half the screws are missing.

Nothing exploded, no smoke, passes the sniff test. Literally, no acrid burnt electronics smell.

Wait a minute! A blown and cracked SMD cap right behind the power plug!
It’s unmarked but looks like a bypass/filtering capacitor so I replaced with a similar 1uf SMD capacitor and retried…

Same result, the capacitor was a red herring.

Time to break out the FLIR infrared camera. If something is taking 1.5A it’s got to be getting hot.

Found a suspect component in the power supply section right by the power switch (lower right corner).

This reverse polarity protection diode is shorted. I suspect lightning damage, reverse polarity or an inappropriate voltage power supply.

Success!

The JV-30 powered on at 9V with a nominal current draw under 500mA.

Used Roland JV-30’s are routinely sold for over $300 on eBay, and this one was had for $5 plus a capacitor, diode, some know how, and a little time.

Bonus Content

It was missing a slider so I whipped one up in OpenSCAD and 3D printed a couple in black PETG at 0.1mm layer height.

3D printing tip: When printing small parts it is often beneficial to print them in separated pairs or with other parts so the part has time to cool before the next layer.

They turned out great and fit perfectly.

Here is the OpenSCAD source code:

/* 
    Roland JV-30 volume slider cap
    by D. Scott Williamson 
    May 16, 2022
*/

$fn=32;
// dimensions
w1=7;
w2=6.5;
l1=13.9;
l2=13.4;
h1=7.16;
h2=6.21;
steps=5;
stepl1=2.8;
stepl2=10.68;
stepl=((stepl2-stepl1)/2)/steps;
steph=(h1-h2)/(steps+1);
rad=.25;
holeh=5;
holew1=2;
holel1=5;
holew2=3.9;
holel2=2.2;

// part
color([.2,.2,.2])
difference()
{
    // basic slider shape
    hull() 
    {
        // rounded footprint
        for(x=[-w1/2+rad,w1/2-rad]) for(y=[-l1/2+rad,l1/2-rad]) t([x,y,0]) cylinder(r=rad,h=.01);
        // rounded top corners
        for(x=[-w2/2+rad,w2/2-rad]) for(y=[-l2/2+rad,l2/2-rad]) t([x,y,h1-rad]) sphere(r=rad);
    }
    
    // steps
    for(i=[0:steps]) 
    {
        t([-w1/2,-stepl1/2-i*stepl, h2+i*steph]) cube([w1,stepl1+i*stepl*2,steph+.1]);
    }
    // + shaped hole in bottom
    cube([holew1,holel1,holeh*2],center=true);
    cube([holew2,holel2,holeh*2],center=true);
}

// Shortcut methods
module t(t) {translate(t) children();}
module tx(t) {translate([t,0,0]) children();}
module ty(t) {translate([0,t,0]) children();}
module tz(t) {translate([0,0,t]) children();}
module r(r) {rotate(r) children();}
module rx(r) {rotate([r,0,0]) children();}
module ry(r) {rotate([0,r,0]) children();}
module rz(r) {rotate([0,0,r]) children();}
module s(t) {scale(t) children();}
module sx(t) {scale([t,1,1]) children();}
module sy(t) {scale([1,t,1]) children();}
module sz(t) {scale([1,1,t]) children();}
module c(c) {color(c) children();}

Upcycled LED Illumination for 3D Printing Area

I was given some salvaged LED lights which became a worthwhile improvement to my 3D printing area.

This is what the 3D printing area looked like before the upcycled lighting. Since all of my prints are automatically video recorded, I either had to leave all the shop lights on or plug in a small lamp when printing in the evening. Results were less than ideal.

There were two types of lights, one unit from illuminated Exit signs was fully self contained, and the other designer lamps had separate power supplies. There were two of each plus some additional power supplies.

The Exit sign units would have been easier to install but the light was too cool and had a harsh unnatural fluorescent look.

It took a little more work to learn more about he designer lamps and verify I had the correct transformers for them.

I initially powered them from My DC bench power supply, discovering they take somewhere over 30 volts DC. Then wired the lights to the transformer that appeared to match them and verified the output current did not exceed the 700ma rating on the transformer. Finally I powered them up for a while to make sure neither the lights nor the transformer got too hot. Note the metal frame is not grounded at this time so is isolated from the CNC rail using a magazine.

The designer lamps have a nice warm light and the lights are clustered but spread over a wider area which helps soften shadows.

Here you see the space where I will install the lights. I decided to hang the irregular shaped lights from the bottom of the top shelf using wire through drilled holes at the three narrow points on each light. I measured and centered the lights and transformers then marked all the holes for drilling. I drilled each of the holes off the edge of the bench with a piece of scrap behind the particle board shelf to minimize blow out and to make sure I didn’t accidentally drill holes into my bench.

Since I had a quart of old white paint on the bench I decided to paint the shelf to further brighten the area. I used florists wire to mount the lights and #8 1/2″ screws and washers to mount the power supplies.

I added some electrical reference to my shop decor. When repurposing used cords, be sure the wire is in good condition and rated for the currnent load of your application. Also be sure to identify and verify the hot and neutral wires. The neutral wire will have the wider blade on the plug and ridges on the wire while the hot lead has a narrower blade and smooth wire. I also learned closing a switch housing with a vice is a bad idea. Fortunately I had a second switch.

Here is the final wiring and test. Note the addition of a green grounding wire screwed to each fixture. All the wiring is done with wire nuts and is secured with electrical tape. There is a wire strain relief mount nailed to the board so the potentially live wires are not hanging from the transformers.

I’m super happy with the results, here is what the 3D printers look like from their cameras, and how illuminated the 3D printing are is in the otherwise dark shop.

Watching the James Webb Space Telescope Cool

For those of you who like to watch grass grow or paint dry, here’s another option: watching the James Webb Space Telescope cool.

The JWST was successfully launched, deployed, and achieved stable orbit. But it’s not yet ready to perform science. It first has to cool down to a few degrees above absolute zero.

There are nine temperature sensors in total. Two spacecraft sensors on the sunny side of the craft:

  • Sunshield UPS Average Temperature (hot)
  • Spacecraft Equipment Panel Average Temperature (hot)

two on the shady side:

  • Primary Mirror Average Temperature (cold)
  • Instrument Radiator Temperature (cold)

and five on the science instruments panel:

  • MIRI Mid InfraRed Instrument
  • NIRCam Near InfraRed Camera
  • NIRSpec Near InfraRed Spectrometer
  • FGS/NIRISS Fine Guidance Sensor / Near InfraRed Imager and Slitless Spectrograph
  • FSM Fine Steering Mirror’

NASA publishes the current temperature data at https://www.jwst.nasa.gov/content/webbLaunch/whereIsWebb.html?units=metric.

To watch how quickly the JWST is cooling, you need to see the historical temperatures. I’ve put together
a dashboard to do just that. I wrote a Python app to scrape the JWST website and record the data in an Adafruit database. And I use Adafruit IO’s dashboard building blocks to display graphs and gauges for each sensor.

You can find that dashboard at https://io.adafruit.com/MrsMace/dashboards/jwst.
My Python code is at https://github.com/w8HAQRHkTx7r/jwst

Hack from slack #1

Jim posted a clever hack on the Workshop 88 slack workgroup recently. Here was his description:

One of the limitations of working with the dear old AT Tiny85 is that it has no UART.  Yeah, we’ve all debugged stuff with an LED or 2, but how about this:  Use an old phone as a serial terminal!My old (2 or 3 phones back) phone supports OTG.  I plugged a USB-serial adapter in, ran up the nice Serial USB Terminal by Kai Morich, and ran Tiny Serial Debug (write-only bit bang serial).  And it works!  That terminal supports CP210X, CH340G, FT232, Arduinos with 32U4 and more.  And it only costs one pin (plus ground)!

Are you interested in learning more about how our members share ideas and knowledge with each other on slack? Consider becoming a member and join in on the conversation with us!

Chess Clock 2.0 using an Adafruit MacroPad

by MACE

I built a better chess clock. It’s no surprise that my first attempt (see http://blog.workshop88.com/2021/07/30/making-a-chess-clock-with-a-circuit-playground-express-user-interface-decisions/), while functional, was difficult to use. The buttons are tiny, you need a lot of prior knowledge to use it, etc. My wife refused to use it.

Just in the nick of time, I received the Adabox 019. It contained a keyboard circuit, keys, keycaps, OLED display, rotary encoder, encoder knob and housing — some assembly required. Adafruit promotes this product as a way to send commands through a USB port to the foreground program running on a computer. There is also a MIDI use case.

The included demo code interprets key presses based on a menu of items that are specific to a given program. You can have multiple menus for multiple programs. You switch between menus using the rotary encoder. Each menu can set the neopixels under the keys to visually group keys by functionality. Here’s an example menu I did for Inkscape.

Inkscape-MacroPad-Menu

Key 1 (upper left) resizes the document to match the selection
Key 2 is for Trace Bitmap
Keys 4-8 are for manipulating layers

It worked, but this use case for the MacroPad wasn’t satisfying. For me, a keystroke on the pad isn’t any better than just using the shortcut keys on the full keyboard. I soon started to hunt for a bigger itch that needed a bigger scratch.

The first one I came up with was to use the example menu framework to simplify my use of various Linux terminal commands. The ls command, for example, has dozens of options. The combination of dashes, case sensitivity, non-mnemonic codes, etc. makes the command tedious to type — especially if you need to use many different options in various combinations. Not to mention that the meanings of the options are different depending of the flavor of Linux!

Here’s the menu I wrote for the terminal on MacOS. I took better care on this menu to color code the keys. The yellow keys are for formatting options, the green key is for recursion, Key4 isn’t enabled, the red keys are for sort order and the purple keys are groups of file extensions. Pushing the rotary key enters the “ls ” command itself.

With an open terminal window, the MacroPad connected and my custom menu selected, I can use the keys to easily form the command that lists “code” files with units, long dates, sorted by size, in reverse order:

<Rotary><Key1><Key2><Key5><Key7><Key12> #These are the key presses

ls -h -T -r -S *.py *.sh *.sed #This is what gets typed at the prompt
-rw-r--r-- 1 appleadmin staff 75B Jul 9 09:40:36 2021 mymoduletest.py
-rw-r--r-- 1 appleadmin staff 72B Oct 19 09:59:35 2020 timezones.py
-rw-r--r-- 1 appleadmin staff 59B Mar 30 16:17:28 2021 getSkyCharts.py
-rw-r--r-- 1 appleadmin staff 58B Apr 2 16:39:43 2021 mymod.py
-rwxr-xr-x 1 appleadmin staff 46B Mar 31 06:38:26 2020 rhi.sh*
-rw-r--r-- 1 appleadmin staff 24B Aug 2 21:47:36 2021 goPad.sh

It works well.

Finally, having just finished my 2-Player+ Chess Clock, I made version V2.0 using the MacroPad. This time, I have a display screen to properly prompt for input and display time remaining, a rotary encoder with an “ENTER” feature for numeric value input and a physical, color-coded button for each player to push.

Here’s the result in action.

Making a Chess Clock with a Circuit Playground Express — User Interface Decisions

by MACE

We are makers. Some of us take an object and reshape it to make something new. Others of us assemble components together. For 50 years, I’ve made computer programs. And I still enjoy it.

In this post, I want to explain about the User Interface challenges I faced while programming an enhanced chess clock.

If you’ve seen the movie Queen’s Gambit (or just about any other movie with chess in it), you’ve seen chess clocks. Chess clocks are used to ensure games end in a reasonable time.

A chess clock comprises two, linked stop-watches. There are two buttons on top. The left button stops the left clock and starts the right clock. The right button stops the right clock and starts the left one. The clocks measure the total amount of time each player has spent thinking about and making their moves. Each player is given a certain amount of time at the start of the game. If a player hasn’t beaten their opponent before their time runs out, that player loses. There’s an indicator that shows which clock is running, and a little flag that drops to indicate that time has run out. In this day and age, digital chess clocks have often replaced analog clocks.

Now that looks like something makeable. A couple of 4-digit, 7-segment displays, a few buttons, a 3D printed case, some LEDs, a microcontroller — and a little bit of programming.

I took a different approach. I didn’t feel like buying and assembling the individual components. I wanted to write the code and begin using it very soon. Also, while chess is a two-player game, my family plays Rummikub which can be 2, 3, 4 or more players — so I wanted a variable number of clocks. I decided to use a Circuit Playground Express (CPX) from Adafruit.

The CPX is a microcontroller board that includes 1 red “status” LED (Pin 13), x,y,z-accelerometer, light meter, JST battery port, USB port for communication and/or power, temperature sensor, digital and analog pins, 7 capacitive touch sensors, 3.3 and 5.0V power and ground, two clicky push buttons, slider switch, infrared tx/rx, speaker, microphone, and (this is the best part) 10 RGB pixels.

It’s a great product to introduce people to programming. Programming can be done with MakeCode (a block based language), CircuitPython or the Arduino IDE. I chose to use CircuitPython and the Mu IDE to make my clock. When the CircuitPython firmware is installed, the CPX appears as a thumb drive called CIRCUITPY when plugged it into your computer. If you copy a file called code.py to the root of CIRCUITPY, the firmware starts to run it. The firmware senses whenever a new code.py overlays the previous one and auto restarts.

The challenge with this project was to design a user interface that can be used for a variable number of countdown timers using only the built-in components on the CPX. Here are the decisions I made.

How to tell how many players will be playing.
When the CPX is powered up, it immediately launches the code.py program which waits to be told how many players there are. It assumes at least two players, so it lights the first two pixels red. If there are more players, press and hold the A button until additional pixels light up. It’s possible to accidentally turn on more pixels than you intended. If this is the case, use the B button will turn pixels off. Code prevents you from setting fewer than 2 players. To finish up this step and move on to the next, tap the A1 capacitance pad. (My CPX is housed in a 3D-printed enclosure and the pads are a awkward to reach. To solve this, I clipped the head of an alligator clip to the pad. Rather than touching the pad, I can touch the tail of the alligator clip.)

How to indicate who’s turn it is.
With 2 players, each player gets allocated 5 pixels. Each set of 5 is a different color. With 4 players, each player gets 2 pixels. A player’s pixels will light up with appropriate color when their turn begins.

How to indicate that the clock is running.
I use the red status led. Each second, I toggle the LED.

How to end your turn, stop your clock and start the next player’s clock.
When the current player is done, they click their button – either button A or button B. When the next player is done, they click their button. Internally, players are numbered 0 to n. Even numbered players share button A and odd numbered players share button B.

How to indicate which player makes the first move.
Games don’t usually last a long time (although some players in my circle have historically taken a LONG time to make their move — hence, the need for this clock) and it’s common to play a second or third game after the first is finished.

For the first game, one of the players is designated the starting player (however that gets decided). That is player #0 and is assigned the first set of pixels and button A. The next player is assigned the second set of pixels and button B. This continues for all remaining players. When playing several games in a row, the starting player of the first game is not necessarily the starting player of the second game. For the second and subsequent games of the tournament, a new starting player must be indicated.

The number of players is the same, the order of players is the same, player numbers, pixels and buttons have all been assigned. None of that needs to change. But the clock does need to know which player will make the first move. The CPX prompts for the identify of starting player by lighting the 1st pixel blue. If the starting player is actually the 3rd player, holding the A button lights up the other pixels. Continue to hold until the starting player is indicated. Code prevents you from turning on more pixels than there are players and from turning off all the pixels. Tapping the A2 capacitance pad will lock that choice in.

When to start the first clock.
The number of players is set. The player to make the first move has been set. The next thing is to activate the clock of the starting player. This is done by covering the light sensor with your hand. When the sensor detects a significant change in brightness, it will start the countdown clock of the starting player, illuminate their pixels and blink the status led blinking.

How much time left.
In this first implementation, the CPX is connected to the Mu editor on a laptop via a USB cable which supplies power to the CPX. The Mu editor includes a serial monitor to which the CPX can write status information (like each player’s time remaining). Mu also has a built-in plotter. If a tuple is written to the console, the plotter will display the values of the tuple in a time graph. If you want to know how much time you have, just glance at the plotter (or the serial monitor). Here we see that player 1 (zero relative) has run out of time and gone negative.

A future implementation of the clock will be battery powered and there will be no plotter nor serial monitor. Instead, a single 4-digit, 7-segment display connected to the CPX’s I2C interface will display the time remaining for the current player. This exceeds the design goal of no additional components, but, what the heck.

What to do if the current player’s time runs out.
I play a sad sequence of tones on the speaker and light their LEDs red.

Here is a two-minute video demonstrating a four-player game with an artificially short time limit.

Yet to be programmed:
Set the length of time: Maybe light up the LEDs. The binary equivalent will be the number of minutes. This would put a 17+ minute limit for each player.
Indicate someone won (rather than someone timed out), game over, start next game. This could be done by shaking the CPX since there is a built-in cpx.shake() function that can be queried.

Where do Workshop 88 members live?

We have members that live all throughout the Western suburbs of Chicago, but most of our members live somewhere in DuPage county. Most of our members live within a 30 minute drive to downtown Glen Ellyn.

Some of our members live a lot closer, though! We have members in Wheaton, Lombard, Carol Stream, and Glendale Heights. Those who live further out include members living in Elmhurst, Addison, Lisle, Naperville, Westmont, and Oak Brook.

Our members all have access to all the makerspace tools, like the woodworking, metalworking, CNC equipment, 3D printers, the laser cutter, and the electronics shop. More importantly, though, our members belong to a community of makers who are all interested in becoming better at making, building, and crafting.

What are you looking to make at Workshop 88? Open house is every Thursday from 7:00-9:00pm.

Laser Cutting a Jigsaw Puzzle

by MACE

My 2.5 year old grand-niece loves jigsaw puzzles. I thought it would be a nice to make a custom puzzle for her using a photograph of people she knows.

Here’s how I did it.

My approach was to take a photograph, glue it to a substrate and laser cut it into interlocking puzzle pieces. I’ve seen my niece assemble 25-piece puzzles, so I wanted to keep the total number of pieces to about that number. The pieces need to be an appropriate size to fit her little fingers. Combining this with the 25+/- constraint, I decided to order an 8×10 print and to cut it into a 5×4 matrix. Twenty pieces is a little light on piece count but it matches the aspect ratio of the photo.

Puzzle pieces need to be sturdy. Simply cutting the photo into pieces wasn’t satisfactory. The pieces need a stiff backing. I considered three materials — 1/16″ basswood sheet, acrylic, and heavy card stock. I ran test cuts on all three materials. I printed three 5×6 test photos and used Locktite 300 spray adhesive to glue the photos to each of the above materials and let them cure overnight. Then I covered the photos with blue painters tape to prevent charing of the photo. It’s best if the width of the tape is LESS THAN the size of a puzzle piece. The 300 adhesive helps ensure that the photo does not separate from the substrate either during the cutting process or when removing the blue tape.

The first material I tested was the card stock. I’d picked up some mat board typically used for picture framing. I cut a series of 1″x1″ squares through the tape, photo and substrate with various laser settings. The best setting seemed to be 10% speed, 100% VC, 100% power and 2 passes. The pieces cut very cleanly. The edges of the square were darkened, but the backside only had a little bit of soot and the blue tape completely protected the photo. The next test cut was a single, 2″x2″ jigsaw-puzzle-shaped piece. I found and downloaded a vector image of a single puzzle piece. It printed beautifully. The stiffness was perfect — just like a commercial puzzle — and fit well when dropped back into the hole left in the test material. I didn’t bother test cutting the other materials.

Finding a 5×4 vector jigsaw puzzle template for the production run was more difficult. I found plenty of .jpg images, but converting them to vectors for cutting exceeded my Inkscape skills. I ended up buying a collection of 13 templates in .svg format on ETSY for $2.50.

For the production run, I printed an 8×10 image and glued it to the mat board. In Inkscape, I opened the 5×4 puzzle template and sized it to 7.5″x9.5″ — slightly smaller than the image. I colored the interior lines blue and the outline red. The plan was to cut the blue first and the red last. This way, the pieces would stay together until the outer perimeter cut through. I added a second layer to the bottom of the layer stack, imported the original .jpg that I had printed and resized it to 8×10. With the two layers superimposed, I made whatever subtle changes were necessary to ensure the best placement of pieces within the boundaries of the photo. Once satisfied, I turned the background/photo layer off and sent it to the laser.

Surprisingly, the settings from the test cuts failed on the production run and I ended up using speed 30% and 3 passes. Once cut, I took each piece out of the laser one at a time, stripped the blue tape and reassembled the puzzle to ensure all pieces fit nicely.

When stripping the tape, there’s always the risk of pulling up the photo as you scrape along the edge of the piece trying to get a foothold to pull. By keeping the width of the tape small, you can ensure that the center of the piece with have two strips of tape overlapping each other.

It’s far easier to scrape at that seam to get started. Once the first one strip of tape is removed, it’s easy to start the second by scraping across the flat, center surface of the puzzle piece instead of along the edge of the piece.

Here is the final result.

I did eventually test cut the other materials. The 1/16″ basswood was sturdy, but a little thin. The acrylic was beefy thick, but light and strong.

Here are the details of the mat board purchased from Michael’s: