Category Archives: Programming

Free Repair: Fix Pioneer Head Unit White Screen of Death (DHT-160, DMH-1770NEX, AVHX2800BS)

by

UPDATE NOVEMBER 2024: Based on comments received here and on YouTube, Pioneer is no longer honoring repairs for this condition when out-of-warranty. That is a great disappointment considering Pioneer has previously admitted the problem was widespread and a manufacturing defect on their end. This means that many owners of their defective head units from 2020-2022 will be out of luck when their sets start showing these common symptoms, if they haven't already.

If you purchased a Pioneer head unit during the covid years of 2020-2022 (DHT-160, DMH-1770NEX, AVH-X2800BS or others), you might find it is starting to fail with a white screen of death. The symptoms will start showing up when you start the vehicle and become more persistent as time goes on. You will get a bright white screen sometimes with vertical lines through it or other major defects including a lack of touch interactivity. Read Full Article

CRT Collective: JVC I'Art 20" AV-20F476 (October 2006)

by

(This is part of an ongoing effort to document the various CRT monitors and televisions that I acquire, with information that may be of relevance to others who Google the same model!)

Here's another freebie new-old stock set I picked up last year. For a 20" set, the inclusion of component inputs makes it inviting for progressive scan devices. This set released in an era when notice stickers were often appended to sets, to advise consumers about the impending cut-off of analog tuning. Read Full Article

I Just Wanted Clean HDMI on a Note 10+ (Telephoto)

by

This week's obsession came when I decided I wanted to repurpose my recently repaired Samsung Galaxy Note S10+ as an overhead camera for the workbench. Its image sensors vastly outperform any ordinary webcam, including my $200 Razer Kio Pro. The distance from my homemade ceiling mount to the workbench tabletop makes the 2x optical zoom of the Note 10+ a perfect fit. But in all the years I owned this phone, I never realized that only the native Samsung Camera app allowed use of its telephoto lens. All other applications, free or paid, are only able to interface with the front-facing cameras, wide angle and standard 1x back lens.

Unlucky for me but fortunately for everyone with slightly newer models, Samsung finally introduced clean HDMI out with their native Samsung Camera app as part of the One UI 5.0 release. Note 10+ and lower are ineligible for the upgrade. My Note 10+ is currently running One UI 4.1 and Android OS 12 with kernel 4.14, all of which are pretty much end-of-life for the phone beyond security patches. Read Full Article

Bally Arcade: Vintage Computing Christmas Challenge 2022 Breakdown

by

Overview

The Bally Arcade / Bally Astrocade / Bally Professional Arcade was an ambitious home computer and video game console combo released in 1978. It sported a 24-button calculator keypad, four joystick ports, a ROM with four built-in applications (Gunfight, Checkmate, Calculator, Scribbling), a light-pen connector and expansion bus and 256 possible colors (8 simultaneous or 2 in BASIC). The joysticks included a trigger button, directional joystick and a 256-position analog wheel on top. Unfortunately, the system was plagued by delays and manufacturing shuffles and never caught on compared to other systems at the time. Several planned add-ons and expansions never came to be, or were only produced through third parties including a full-featured keyboard. It made a cameo appearance in National Lampoon's Vacation and a few catalog appearances, but didn't get a lot of media fanfare beyond that. However, for many years there existed a very devoted group of users, newsletters and more.

45 years later, the system still has a small but ambitious group of enthusiasts involved in the preservation and advancement of the system. Major shout-out to Adam Trionfo and Paul Thacker who have done an incredible job scanning and preserving all artifacts of Bally on BallyAlley.com. Much of the archives originate from the Bob Fabris collection, who ran the largest newsletter Arcadian for years and generously offered tens of gigabytes of materials for preservation. This is the polar opposite of many vintage systems where almost all traces of documentation have been lost or remain in some dusty corner of a basement.

Bally was impressive in that it packed a lot of functionality into a variant of Palo Alto Tiny Basic that also brought native BASIC support for interfacing with the controllers (including the analog dial), multi-voice sound control, a LINE and BOX command with several effect options and several other features that on other platforms required manual PEEK/POKE operations (Bally BASIC also supported poking and peeking including across the entire ROM to tap into handy machine language features). The system only had 4K of internal RAM and only 1.8KB available for user space, which is shared with the screen memory. This is achieved through some clever interweaving of both BASIC code and display output on even/odd bits. This limitation reduced the display possibilities to a single background and foreground and cut out some other advantages of raw machine language.

Vintage Computing Christmas Challenge 2022

The 2022 annual BASIC challenge by Logiker proved very popular, with many users working out an implementation of a Christmas star across many varieties of BASIC. The core objective was to reproduce the above 17x17 star pattern in as minimal code as possible. It was fun and educational to watch the evolutions and iterations of entries recreating the exact pattern above — the grand winner replicated it on a ZX81 in just 27 bytes thanks to its innovative single-byte commands. In fact, Bally replicates that one-byte command functionality for most of its limited BASIC commands, in the interest of both simplifying the typing on a calculator keypad and reducing the consumed space.

While the vast majority focused on the core competition, I grew more interested in the "wild" category. This wasn't part of the real challenge but allowed creative interpretation of the design without fixating on length or exact replication. Bally BASIC had been forgotten and I thought this would make a fun exercise to get my feet wet on this 1970s variant of BASIC. The wild category made sense to me since Bally BASIC doesn't even support enough on-screen lines to fit the original star without scrolling. But also because I wanted to see the potential of Bally's built-in graphic functionality.

You can see a video rundown of the snowflake challenge entrants above. My Bally contribution kicks in around 18:20. The live chat shows a few people enjoyed it as it played: "wow... awww cute... very nice..." The host of the challenge, Logiker, also said it was his first discovery of the Bally Astrocade and he enjoyed researching about it: "This is a fantastic release. To be honest, at the beginning, I even didn't know what a Bally Astrocade was. And now seeing how you have to type in the program: just wow! That's nostalgic pure!"

Bally Snowflake Entry: Line-by-Line

Line 1: Comment

In Bally BASIC, comments are designated with a . as the first character following the line number and optional space. This differs from most variants that opted for REM but also makes a lot of sense in the interest of saving precious bytes of space.

Line 10: Variable Declarations and Clear

The BC and FC variables are built-in to Bally BASIC and represent the background color and foreground color. Bally has 256 possible colors, but in vanilla BASIC you can only select a singular ink and paper for the entire screen display. The screen immediately updates whenever either of these values are updated, opening the doors from some interesting transitions and effects from the large bank of available colors. For the initial appearance I use a red background color (0x48 = 72) and black foreground color. The best way to review the Bally colors is through the Astrocade Pallette available on Bally Alley (you'll have to convert the hex values to decimal).

The D variable is indicative of the initial draw mode. The LINE and BOX commands available in Bally BASIC support four different draw effects passed as the final parameter:

  • 1: Draw using foreground color (FC)
  • 2: Draw using background color (BC)
  • 3: Draw using reverse color (inverts whatever is drawn over)
  • 4: Draw using no color (useful for moving the point without drawing).

The variable is the initial step size that the start shape will be drawn at, essentially how many pixels of blank padding will appear between each iteration.

Both D and the will be randomized later on to create the everlasting animated appearance.

Lines 20-70: Defining the Basic Star Pattern

This section rather cryptically defines the mathematical pattern of the overall shape. I first brainstormed how the star could be reduced down to some basic repeating values and symmetry based on the mannerisms of the LINE operation.

In the world of Bally, coordinate (0, 0) is the center of the screen. The horizontal (X) bounds run from -80 LEFT to 79 RIGHT, while the vertical (Y) bounds run from 43 TOP to -44 BOTTOM. The LINE command begins in the center of the screen at (0, 0), or where the previous line ended unless manually set beforehand. The destination points are also relative to the center origin of (0, 0). With that in mind, I picked an arbitrary start point for the star. I decided to start from the right-center and drawing up and around, counter-clockwise. So the numbers below indicate the X/Y offset from the start point to draw the top half of the star in its smallest form factor.

  • X: 2, 1, 1, 0, -1, -1, -2, -1
  • Y: 1, 1, 2, 1, 2, 1, 1, 0

This can be likened to the old days of LOGO/TURTLE. To construct the basic design, consider we start at offset (1, 0). To draw the first diagonal bit of the star toward the top-right, we would use an offset of (2, 1).  From the end of that point, we'd draw to offset (1, 1) and from that to (1, 2) and so on based on the mapping above. When all eight offsets are drawn to, we'd have something similar to below, which completes one half of the star.

From the pattern above it becomes evident that we only need to store those eight values, and then reverse the order and multiply the Y axis by -1 to draw the bottom half.

I begin by creating a 7 value loop, which will iterate to store the offset data that we need. Even though it takes eight points to draw half the star, we can take some more shortcuts as will be described next.

Bally BASIC does not support AND/OR/THEN/ELSE operations. Instead, we can mimic that behavior by adding multiple IF statements to the same line. Line 30 instructs the program to run the computation of N=(I+1)/2 when I is 2-5, so it will not run on the first two nor the last iteration.

is a newly defined variable that at this point is not useful itself, but the computation it is assigned is. Based on the iteration, the result of this operand will be equal to 3/2 (1 remainder 1), 4/2 (2 remainder 0) and 5/2 (2 remainder 1) as the loop progresses. The remainders are the important part here, as described next.

Bally has two fixed arrays that can store integer values. They are defined as @() and *(); in the actual system the asterisk is a unique character separate from the multiplication symbol. The @() array consumes the space in memory directly following the BASIC program, while the *() array begins in the final available bytes of memory and goes in reverse order (so is less susceptible to being overwritten if the program expands). I utilize both of them, one for Y and one for X, starting with the @() array on line 40.

The RM variable is built into Bally BASIC and returns the remainder of the last division operation, in this case from in line 30. The division at line 30 divides (I+1) by 2 so the remainder will either be 0 or 1 depending on the iteration.

At the end of the final loop, the @() array will consist of: [1, 1, 2, 1, 2, 1, 1, 0]. This matches the Y plotted points brainstormed above, but without having to explicitly define each in code.

Line 50 utilizes the second available array and, starting from its 4th index on, assigns it the inverse of what had been assigned to the @() index in the preceding line. There's no reason why I couldn't had just used the @() array for all of this, except part of the challenge was thinking differently and stretching our BASIC interpreters as far as they can take us in the interest of potentially saving some bytes.

If we ignore the following line 60 for the moment, if the loop completed at this point the *() array would consist of: [0, 0, 0, 0, -1, -1, -2, 0]. You can see the second half of the array is beginning to match the second half of the X plotted points brainstormed above.

This line goes back and alters the first half of the second array that was skipped in line 50, starting with index 0 when I = 4. Here we directly assign the value stored in @(I) to *(I). This is part of the inverse pattern discovered previously. It only executes from interval 4-6 of the loop, so will only alter indices 0, 1 and 2. Since *(3) = 0 in our pattern, we didn't need to do anything with that spot.

With all of that said, the final *() array will consist of: [2, 1, 1, 0, -1, -1, -2, -1]. Success! We have successfully carved out the full X plotted points brainstormed above, and all of this was able to be done in just 7 loop iterations instead of 8 😉

This completes the loop. At the end of the cycle based on the above conditions and allocations, we have two arrays ready for use:

  • X PLOT POINTS: *() = [2, 1, 1, 0, -1, -1, -2, -1]
  • Y PLOT POINTS: @() = [1, 1, 2, 1, 2, 1, 1, 0]

Comparing the data above to the graph paper image previously, it starts to become clear how we will offset the line points by these values and a given multiplier to draw the star in any size we want.

Lines 80-150: Drawing the Star

With the heavy lifting done in the pattern calculation section previously, the subsequent lines put those points into action.

I decided arbitrarily to establish the outer loop from 2 to 21. This loop value U corresponds to the multiplier used for scaling the current iteration of the star shape. A value of 2 will plot the first star as a small shape in the center of the screen, while the value of 21 will stretch the shape close to the boundaries of the available screen space, which is limited to 43-44 pixels above and below the center point. Depending on the step value S (default 3) it will skip that number of pixels between each increasingly enlarging star shape to give it more interest than a purely solid star shape.

In line 90, the XY variable is assigned to the current loop iteration. XY is another in-house variable that Bally BASIC provides, and it corresponds to the position of the last LINE command. Likewise, it can be set to a new value to indicate where the next LINE command should start from.

Since XY uses a WORD value (double byte) it has to pack both the x and y coordinate into one. To quote from the manual, "=&0=&" I utilize this feature to offset the start of the line from center. Since I always begin drawing the star from the center-right, it is possible to assign XY the value of U which will set the start point to the matching coordinate to the immediate right of the (0, 0) center.

If you're looking to use this command to plot elsewhere on the screen where Y is not zero, it gets more sophisticated to calculate. An exhaustingly detailed guide on using XY and practical cases for it can be found in this XY Tutorial (PDF) by Timothy Hayes from 1980, courtesy of Bally Alley. An alternative approach to moving the line without drawing is to pass the value 4 as the end line parameter, but this is less performance optimal than direct XY assignment.

I reset to 0 so it can be used as a sort of multiplier to manage drawing the upper half and then the inversed lower half later on based on where we are in the loop.

The new variable M is also initialized as part of the upper-to-lower translation later on.

The inner loop consists of 16 interval segments to inclemently plot the X/Y data to the line command. Remember, we only defined eight values in the arrays so once we reach midway through the loop, we'll need to switch things up a little to draw the inverse for the lower half.

When I is greater than 7, it will have completed the eight line calls that comprise the upper half of the star. So we now inverse and M to be negative to influence the subsequent draw calls.

The magic of all lines, we finally have reached the LINE command itself. The syntax itself is simple, taking in a singular X, Y and D (draw mode) value.

  • X: *(I+(8*N))*U*M
  • Y: @(I+(8*N))*U*M
    • Both X and Y use the same formula for plotting.
    • (8*N) will equate to 0 for the first half of the loop, and -8 for the second half. We add this value to the current interval I to retrieve that value from the X plot array. Effectively, we are telling the program to go back to the beginning of the array to read it again for the lower half.
    • U will equate to the outer loop's current interval, and acts as a multiplier for the plotted coordinate/offset. If the outer loop is at 10, then each value in the *() array will be multiplied by 10 to scale the lines by that amount.
    • M is the end multiplier that will be either 1 or -1 depending on if we are on the first half or second half of the loop. Since the second half of the star is drawn in negative Y-space, multiplying everything by -1 when necessary gets us what we need.

    The D value at the end is what tells the line whether it should draw using the foreground color (1), background color (2), reverse the existing color (3), or don't draw anything (4). The default value is 1 because I always want to draw a baseline star when the program first runs.

    This line smoothly fades in the background from red to blue and the foreground from black to white, by incrementing FC and decrementing BC by a given amount with each iteration. This transition happens within moments as the first star is drawn, but adds a touch of polish. This line could easily be adapted to slowly evolve the background color, even cycling through all 256 colors with each star iteration, which could then act as a true screensaver without fear of color burn-in on the old style CRTs!

    Alas, we repeat the inner loop followed by the outer loop. This order ensures that all 16 strokes for the given star are drawn before the radius is expanded and the next one begins. This will repeat while U is 21 or less.

    Line 160: A Flair of Randomness

    As the program concludes, I give the value of D (draw mode) a random value between 1 and 4, and (star radius step size) a random value between 2 and 11. The RND() command in Bally BASIC will range from 1 to the value passed, inclusively. It's always worth checking any BASIC or non-BASIC variant for how the randomizer works, as many are 0-based or exclusive to the value passed.

    Initially I had constrained the D value to between 1 and 3 so that every cycle would either draw, invert or erase. But I found that allowing for the invisible line mode enabled the design to stick around for a while on occasion before morphing into another style, which I found more elegant.

    The combination of these draw effect modes and varying step size leads to some really nice glistening-style snowflake designs. At times when the mode is inverted there will even leave residual snowflake particles in or around the overall star shape, which makes for a creative appearance.

    Line 170: Repeat Endlessly

    The final line of the program sends the user back to line 80 to begin the drawing cycle all over again. The program can be halted by pressing the HALT key on the keypad, which is located on the same key as RUN.

    Cassette Saving Characteristics

    The original iteration of Bally BASIC used the common Kansas City Standard 300 baud transmission rate to save and load data from ordinary cassettes. It had a separate interface adapter that plugged into the light gun and 3rd person controller port. You'd hook an ordinary cassette recorder into the IN/OUT ports to write data and read it back. The revamped version known as Astro BASIC  (or AstroBASIC) supported the much faster 2000 baud transmission speed and had an all-inclusive interface that ran directly from the BASIC cartridge. One mild inconvenience with it is that you have to swap connectors if you are reading or writing, as it has only a single 3.5mm jack.

    Input/Output Commands

    Writing data is done by pressing record on the cassette player, and then executing the :PRINT command. The colon in front signals to send the data to the interface out, rather than the screen. This transmits the data to the cassette and returns to the cursor prompt when complete. Bally even included a form of data verification, if you run the command :INPUT and then play the saved cassette data back, it will compare the checksum to your code and alert you with a '?' if there are any data inconsistencies.

    Reading the data is done similarly, except you call the command :INPUT and then play the cassette back with its audio out jack connected to the Bally BASIC interface. In the 300 baud version of BASIC, the data lists in real-time as it loads so you can quickly detect any errors caused by improper volume or other circumstances. The 2000 baud version loads everything invisibly.

    The original version of Bally BASIC also had a :RETURN option to automatically stop the cassette interface when that command was reached. Developers would include this at the start of their program. If a user would then load the program using ":INPUT;RUN" it'd load everything and then run, while stopping the interface automatically.

    Astro BASIC also introduced a :RUN option for loading machine language applications more easily. "The load will begin at the top of the screen (4000H or 16384D). When the load is completed control will be transferred to this first address. The block loaded is limited in size only by the need to avoid interference with the stack area."

    Screen Capturing

    Since the BASIC code and screen data share the same memory address within the Bally (interleaving even and odd bits), saving the data to cassette transfers all of those bytes over as-is. This means that anything on the visible screen when saving the data will be reflected when you reload the program. At 2000 baud, this takes around 20 seconds, or more than two minutes at 300 baud.

    As the data loads, the screen will update in real-time with whatever bytes have been fetched. This incidental effect results in developers being able to get more creative and display a title or loading screen of sorts, before the user runs the app. This can be used to display instructions, graphics or other elements as part of the data load itself. A similar technique exists on the Interact Home Computer, where cassette data first loads a title screen as part of the memory dump before loading and executing the actual program.

    I use it in the Bally Snowflake program to display a red/green color combination and one of the snowflakes generated from the program. I achieved this simply by running the program, halting it when a desired shape was on screen, and then entering the commands seen in the load screen. You can get much more crafty than this, by embedding the :PRINT command within part of the code execution so it doesn't appear on the screen itself. I could had triggered a cleaner end by wrapping the follow commands into a line on a manual trigger from the running program: "BC=72; FC=165; :PRINT" and then you'd only see the star in the final output. But I also felt it was cool to see a few artifacts like that as part of the initial load.

    Emulation

    Typing on the original 24-key calculator pad on the Bally is not the most enduring of experiences. For development of this program, I relied largely on MAME and as part of it began developing a front-end keypad that would allow more natural keyboard input than what's currently possible. I also created a custom 24-key control pad overlay for the Genovation CP24 that I could hook to my computer and map to MAME's inputs to facilitate a somewhat more comforting but not any less tedious vanilla typing experience.
    
    In the video above, you can see me coding this entire program out using my custom vinyl control pad. The woodgrain trim came from Walmart for under $10 as shelf wrap, which I fed into a thrift find and subsequently "hacked" Cricut to print custom vector that conformed to the pad. I 3D printed the text on another second hand Resin printer.

    In the works is a front-end keypad that I am currently developing and testing in-house for use on MAME. It will support:

    • The full 24-key emulation just like the real machine
    • Single-click direct entry so you can click on any symbol or command without having to first press a SHIFT modifier.
    • Direct line input where you can type a line on your normal keyboard and press ENTER to send it to MAME.
    • Batch script execution where you can type or paste in multiple lines into a text area and send it to the emulator.

    This is quite a revolutionary enhancement to what previously required archaic coding mechanisms. One exception are the useful but generally dated tools for 300 baud typing and conversion available on Bally Alley. Not all of them will run on 64-bit operating systems and some are DOS or command-line based. I used those tools when porting an old type-in (Munch) to 300 baud, in addition to my own front-end for porting and saving via 2000 baud Astro BASIC in MAME. The emulator supports 2000 baud cassette emulation including saving and playback for making clean digital WAV files, but lacks a 300 baud feature set.

    More on this front-end interface in another blog post.

    If you're interested in the full bundle of my Bally Snowflake entry with additional documentation and the WAV file to play on a real or emulated device, you'll find it over here: https://ballyalley.com/program_downloads/2000_baud_programs/misc/misc.html

     

Retro Fix: Montgomery Ward CyberVision 2001 (Work In Progress)

by

(This article will serve as a compendium of knowledge about the incredibly elusive Cybervision 2001 system, for which few sites or articles exist online and no prior service manuals, schematics or reference materials have ever been published. This post will serve both as a well-documented exploration of my repair efforts, technical documentation, media details and more.)

I recently acquired the all-but-forgotten Cybervision 2001 (trademark stylized as "CyberVision 2001") , another late-70s attempt at breaching the home TV-hookup computer market. This system was sold exclusively in the Montgomery Ward catalog, and was featured prominently in a two-page opening spread in its 1978 Spring/Summer edition. The set sported the RCA 1802 CPU, 4K RAM and 1K ROM. The one I received is of multiple levels of despair and with little to no information, schematics and materials to go by online I figure I'll start a blog post to chronicle my experience. I will fill in with photos and/or videos in time.

Initial Observations and Overview

The set is housed in an all-wooden, blond-tone enclosure. This is unusual compared to the common plastic moldings seen in most systems from the era and gives it much more of a prototype feel than other sets I've worked on. It has a simple woodgrain inspired logo adhered to the front surface, a large volume control potentiometer, simple red power light indicator, and a mini push-button start/reset switch. These are all drilled and affixed directly to the otherwise plain wooden face, with the words VOL, ON and START stamped below them.

As was common at the time including with competing products like the Interact Home Computer, the top of the case included storage space for up to six data cassettes, or as the marketing referred to them — Cybersettes (a term which phonetically garners a very different sort of vision in modern times). The computer has a built-in cassette deck as the only means of data transfer, but sports a 2000 baud speed which was a feat for the time to make for rapid data access compared to the more common 300 baud counterparts. Perhaps most innovative is its use of a stereo head and internal speaker, so that each cassette program can playback studio quality cassette music and narration while simultaneously loading the application data into the computer. Internally the OS checks for a particular byte pattern when the data is loading to know when to stop or proceed, and through various uses of this functionality also enabled retrieving data in real-time off the cassette to continuously update the available 2K of data RAM.

There is a hardwired 12V AC power adapter in matching color, with the wires screwed into the face of the adapter. Initial power readings were around 14VAC without load, which was within specs but still inevitably worth replacing with a more modern 12V alternative for the longevity of the machine. The controllers are designated LEFT and RIGHT and are 40-key membrane style rectangles with A-Z, 0-9, ON, OFF, CLR and ENT buttons. Inside of the shell it is revealed the actual keypads are manufactured by Texas Instruments, not surprising considering they also carried a line of matching 40-key calculators at the time.  They run down a ribbon cable and connect through two separate bulky ports on the back of the machine. I've seen more crude interfaces than these controllers, including the Bally Arcade which only had 24 calculator keys to input and program with. The controllers have a black plastic shell and are embossed with the CyberVision 2001 logo.

The system connects through ordinary RF into a black or white or colored television set. It has a fairly boilerplate tuner internally and you can also toggle between channel 3 and 4.

Basic Hardware Specs

  • 1802 microprocessor
  • 1K ROM
  • 4K RAM (2K program memory and 2K video memory)
  • 2000 Baud Two-Channel Cassette for Syncing Audio and Computer Data
  • 128x96 Color Display

First Layer of Problems

Upon opening the case by removing the four screwed-in base stands, it was immediately observed that the tape belt had decayed over time and was severed. This is extremely common for cassette players from the 70s-80s. A makeshift solution is sometimes to use loom bands or similarly sized rubber bands, but long-term you'll want to replace with a comparable sized cassette belt widely available online. The broken one from the set measured around 25-26cm end-to-end, which would be around 8cm diameter belt. It's pretty easy to tell you have found the proper belt size replacement by playing a tape and listening for audio abnormalities as well as any tape eating symptoms indicative that the belt is not operating to spec.

I found several SRAM chips (P2101 - 256x4) were not well socketed and one was dislodged nearly in half, so reseated these. The RAM is arranged in four logical banks on the board, but I haven't even explored half the ICs yet so am still very unfamiliar with the overall logic board. Since no schematics or service manuals have been shared for this system, it's going to be a lot of manual review to figure out the workings.

There was one large electrolytic hanging off a terminal strip that bridged the cassette interface with the internal amplifier and logic board, I believe a 1000uF but will have to double-check. I replaced it with a new capacitor after poor readings from an ESR meter. Eventually I powered up the machine enough to review its baseline status. A corrupted version of the CyberVision logo appeared on the screen, which was a great indication that the most crucial components all were behaving fine including the CPU and ROM. I suspect there may be a few bad RAM sticks int here, though after manually shorting the reset wires the logo generally would clear up. Also, the reset switch itself was broken off internally, so will need to be swapped.

The cassette initially ate tapes I put in it, and after cleaning and re-adjusting the pinch roller and capstan as well as reworking the belt a bit, I was able to play a cassette to a reasonably decent level of quality and accuracy. But it didn't last long. Suddenly the magic smoke arose from a 22K resistor from the cassette circuit board. I am guessing 22K based on the three bands that weren't incinerated in the poof and checking other areas on the board to find comparably colored ones and then checking the four band color calculators online. I replaced that but another power-up revealed more smoke from the power area of the logic board.  This time I discovered at least one if not several cracked rectifier diodes (WEP170) that make up the bridge rectifier labeled D1-D4 on the board, right near the AC power and large 2200uF capacitor. These diodes have specs of 2.5 Amp 1000V. Era accurate equivalents include HEP170, ECG125, R250. I don't have any 2+ Amp 1000V diodes in my toolbox at the moment so have some replacements on order.

When examining the cassette board closer, I noticed a couple of spliced together wires soldered to a pad that had lifted up along with some of the tracing. I followed the trace and added a bodge wire from the end point back to the spliced wires. Initially I was able to get the audio to play but eventually all I would get is a buzz regardless of playback. I diverted the audio out from the amp board to an auxiliary cable into a dedicated Bose system with similar symptoms, and likewise am not seemingly getting proper readings from the head itself. So this will need to be explored again once I have some more components on hand. I started replacing some of the caps on the cassette board, but there are many of them. The cassette component plugs into the logic board using two three-wire plugs (including ground). One plugs in near the AC power and supplies power to the cassette, while the other is labeled "TAPE TONE" and is where the actual data side of the cassette routes (the right channel). The audio side routes instead to an amplifier and then to the output speaker mounted inside the cabinet.

If I can get the main logic board back in operation, another experiment will be to wire up some feed directly to the input line on the logic board. If I'm ever able to read the data and load a program, that'd be a massive milestone even before fully fixing the cassette side of it. The cassettes themselves are rare and not archived anywhere online. I have a few that I am working to digitize in their true stereo format. Unfortunately my sound card and interface also suffered a malfunction in recent months so I am using work-arounds at the moment but have found success routing from a 1980s Panasonic stereo to my Focusrite 2i2.

A Note About Disassembly

Although it's easy enough to remove the wooden case by simply unscrewing the four rubber bases screwed in, it becomes a bit more tedious to get at the underside of the logic board. You will want to desolder the wires from the LED and reset switch (or from the board side) so that the wooden cabinet doesn't need to tag along. Then there are four bolts in each corner of the board that you can easily unscrew the nuts and washers using your fingers or a pliers. However, the board still won't come out. There are two 7805 voltage regulators on the underside of the board, riveted into the base case itself (originally a NEC 14305 and a NEC 7805H, TO-220-3L). The rivets need to be removed for these to release from the base. In my case a drill bit from inside out to remove the inner core, then a pliers to pull out the remnants of the rivet worked well. Even then, there's also a plastic riser tab in the center that you have to pop either out of the board or out of the case, again a pliers can be handy.

With all of the above taken care of and the two cassette connectors removed, you should be able to isolate the logic board to replace most components. The back accessories will still be connected so if you need absolute access to the underside of the board in ways that you can't manipulate with the peripheral connectors attached, some more work will be necessary. But I had no trouble propping the board up and even upside down with the back peripherals still affixed and could desolder and replace components easily.

Voltage Regulators, Revisited

The Cybervision 2001 uses two of the classic 7805 +5V voltage regulators. As mentioned, they are factory-riveted into steel base plate of the system. This is for good reason as these components are famous for getting blister-scorching hot in a matter of seconds if not properly cooled with an attached heatsink. These ones convert 12-14V input into 5V output.

Unfortunately the permenantly riveted solution makes the entire logic boar inaccessible for repairs. After drilling out the rivets, I found that using 6-32 x 1/2" machine screws with nuts made for an adequate and easily removable alternative. I applied new thermal paste to the base of the regulators before bolting them down.

In the process, I discovered one leg of the 7805 nearest the failed bridge rectifier circuitry was severed under the board. And the other had a loose solder connection on the unregulated-to-center-pin .1uF 12V ceramic cap. I removed both voltage regulators and even the one still in tact seemed brittle and was registering unusually on my multi-tester, so I exchanged both for new 7805s.

Without these regulators bolted down to the base, the heat build-up on these grows drastically fast. Within 5-10 seconds their thermal protection kicks on and immediately the output drops, simultaneously underpowering everything attached. If you're using a device that starts to exhibit strange video artifacts and loss, tearing or other symptoms it is always worth checking these sensitive voltage regulators and make sure the input and the output are steady and within spec.

Modern Alternatives

These days, several incredible drop-in replacements for 78xx series regulators exist. Through the use of buck converters or mini DC-DC adjustable output circuits, we can achieve the same result with much more reliability and none of the heat. Most of these replacements allow you to specify the output voltage anywhere from 1.8V through 12V and offer even greater flexibility with input voltage, so can be used for +5 and +12V rails common on vintage equipment. The sets boast an impressive 97% or higher efficiency rate.

I will be swapping the regulators with these modern counterparts after evaluating several different styles. This includes:

  • R-78B5.0-1.5L (available via Digi-Key): Described as a Linear Regulator Replacement DC DC Converter 1 Output 5V 1.5A 6.5V - 18V Input this is a drop-in, pin-compatible replacement for the 78XX series linear regulators in a similar TO-220 form factor. At the time of this writing, they are $12.97 each, so considerably higher than a pack of 7805s but also a vast improvement.
  • 78xx Replacement (SD8942) - This is a CC-BY-SA 3.0 replacement designed and shared by Stefan Wagner. It mimics the basic regulator style circuitry in the same footprint as a TO-220 linear, but uses a modern DC-DC converter IC. It supports variable voltage by soldering different resistors as detailed in the chart. A 5V converter typically uses a 110k and 15k resistor depending on the voltage reference (typically 0.6). The PCBs can be made via JLCPCB for under $10 for 30 of them using the provided design/Gerber, and I imagine that is similar via PCBWay. The majority of necessary surface mount components will already be in one's toolbox, and even the step down ICs are under $1.50 each. I look forward to constructing these as very cheap DIY converters.
  • 5V Mini Voltage Reducer (example on Amazon): There are endless variants of this sort of component used largely in Arduino and DIY modern electronic projects. They are not form-fitting to be direct replacements for legacy regulators like the ones above are, but still have all the same options and pin-outs so can easily be worked into old projects as well. Most of them have adjustable (but fixed) voltage in similar ranges to the ones above. A 10 pack of these will cost around $12, not much more than a pack of 7805s.

Will update my findings in the future.

Cassette (Cybersette) Releases

A currently undetermined number of cassette tapes were released for the CyberVision 2001/3001. Original members of the Cybervision team indicate that "20 to over 40 titles" were released. I will be updating this section as I discover and catalog them. In my digitization efforts, I will also attempt to notate the timestamps of data and audio for further review and testing. A promotional interview announcing the system stated that "Wards is developing hundreds of these Cybersettes in many categories" and the initial catalog listing included 40 titles that were due for release in Jan-Mar 1978. Staff later acknowledged they overpromised and were unable to complete the magnitude of software titles anticipated.

The system used the LEFT CHANNEL for studio audio recordings that would playback through the internal speaker, and the RIGHT CHANNEL for 2000 baud data transfer that would feed directly into the logic board. Two separate connectors ran from the logic board to the cassette interface, one to feed the audio and the other to control power to the motor. This allows the system to programmatically stop the tape deck and wait for user input before continuing.

The listings of these titles gets more complicated as some changed titles or SKU numbers between 1978-1979 so appear differently in the few catalogs they appeared. Eventually this list will be better consolidated into a spreadsheet.

Introductory Series 1

This was the cassette that shipped with the Cybervision 2001 unit and included eight different activities.

Side A

  • Application Selection Menu
    • 1. Adjustments
    • 2. Subchase
    • 3. Biocycles
    • 4. Meet the Meter
    • 5. Flashy Fractions

     Adjustments
    Sub Chase
    Biocycles
    Math Madness: The Metric System ("Meet the Meter")
    Math Madness: Fractions ("Flashy Fractions")

    Side B

    • Designer
    • Bulldozer
    • Trivia
    • Bedtime Story

    Game Series ($9.95 Each or 5/$39.80) - Montgomery Ward 1978-79 Catalogs

    Cybersettes available after January 1, 1978:

    • 101 - Maze: Find your way out!
    • 102 - Bullfight: Listen to the crowd!
    • 103 - Mastermind: Who's the smartest?
    • 104 - Trivia: So you think you know?

    Cybersettes available after Feb. 1, 1978:

    • 105 - Slot Machine: Win a bundle!
    • 106 - Moon Base: Land the ship!
    • 107 - Escape: Break out if you can!

    Cybersettes available after March 1, 1978:

    • 108 - Pinball: Beat the "wizard!"
    • 109 - Starship: Explore the universe!
    • 110 - Tank Fight: See, hear its power!

    Educational Series ($9.95 Each or 5/$39.80) - Montgomery Ward 1978-79 Catalogs

    Cybersettes available after January 1, 1978:

    • 201 - Number Concepts (Fish by Number): Pre-school, kindergarten. (Renamed to Fish by Number by 1979)
    • 202 - Math: Grade 1.
    • 203 - Spelling Bee: Select vocabulary.
    • 204 - Crossword: Select difficult.
    • 205 - Language Arts: Pre-school, kindergarten.
    • 206 - Language Arts: Grade 1.

    Cybersettes available after February 1, 1978:

    • 207 - Math: Grade 2.
    • 208 - Math: Grade 3.
    • 209 - Math: Grade 4.
    • 210 - Language Arts: Grade 2.
    • 211 - Language Arts: Grade 3.
    • 212 - Language Arts: Grade 4.

    Cybersettes available after March 1, 1978:

    • 213 - Reading: Grade 1.
    • 214 - Reading: Grade 2.
    • 215 - Introduction to Money Management.
    • 216 - Hangman: Word game.

    Home Series ($9.95 Each or 5/$39.80) - Montgomery Ward 1978 Catalog-79 Catalogs

    Cybersettes available after January 1, 1978:

    • 301 - Income Tax: Preparation aids and data bank.

    Cybersettes available after February 1, 1978:

    • 302 - Tools and Their Basic Functions.

    Cybersettes available after March 1, 1978:

    • 303 - Checkbook (Dollar Watch). 10-memory calculator. (Renamed to Dollar Watch by 1979)
    • 304 - Vegetable Gardening.
    • 305 - Clock and Alarm: Fundamental functions.

    Story Series ($9.95 Each or 5/$39.80) - Montgomery Ward 1978 Catalog-79 Catalogs

    Cybersettes available after January 1, 1978:

    • 401 - Hansel and Gretel.
    • 402 - Rumpelstiltskin.
    • 403 - Beauty and the Beast.

    Cybersettes available after February 1, 1978:

    • 404 - Three Billy Goats Gruff.
    • 405 - Emperor's Nightingale.
    • 406 - Three Little Pigs.

    Cybersettes available after March 1, 1978:

    • 407 - Three Bears
    • 408 - Jack and the Beanstalk
    • 409 - Sleeping Beauty

    Game Series ($16.95 Each) - Advertisement Listing

    • 107 - Escape: Use your ingenuity!
    • 108 - Star Flex: Beat the wizard!
    • 104 - Trivia II: So you think you know the little things?
    • 486 - Designer II: With scratchpad included.

    Home Series ($16.95 Each) - Advertisement Listing

    • 304 - Vegetable Gardening: Fundamentals in treatment and control.
    • 484 - Address Organizer: Includes a scratchpad.
    • 485 - Menu Organizer: Includes a scratchpad.
    • 481 - Dollar Watch: Checkbook function. 10-memory calculator.

    Educational Series ($14.95 Each) - Advertisement Listing

    • 216 - Hangman: School days word game.
    • 205 - One or More: Grade 1 grammar.
    • 202 - Battleship: Grade school educational game.
    • 204 - Crossword: Select difficulty.
    • 213 - Mouse in My House: Grade 1 reading.

    Story Series ($14.95 Each) - Advertisement Listing

    • 405 - The Emperor's Nightingale
    • 404 - Three Billy Goats Gruff
    • 402 - Rumpelstiltskin

    More on Cassette Reverse Engineering

    The system ROM and programming logic reads particular data cues to stop or start playback. Upon hooking a scope up to the secondary connector that the cassette interface typically feeds into, the middle pin will read 0.5V high when powering the cassette and awaiting data. When the program needs to handle user input, a signal is sent that stops the current going to this pin and, in turn, powers off the cassette player.

    This excerpt from Ken Balthaser's reflection via GameDeveloper.com seems very relevant here:

    My single technical contribution, sort of, was the A5 synching system that we used. The CyberVision system used an off-the-shelf stereo cassette tape player for the data and soundtracks. The data was recorded on one track and the audio was recorded on the other. The system would load the data and begin executing the code while the audio played. A problem arose because there were slight differences in the motor speed for each tape deck. This meant that if a deck played back a little bit faster or slower then, after time the audio would get out of synch with the code.

    That's when my experience in slide/sound productions came in handy. Multiple slide projectors were kept in synch or triggered to a sound track by using audio blips that would trigger the control box to change slides. I mentioned it to Joe as a possible solution to the synch problem. After some thought, he came up with a solution based on that type of system - A5's. The hexadecimal number A5 produces a unique series of bits as ones and zeros. By stringing a series of these A5's together the system would monitor the data track and “listen” for this unique series of bits. When it detected them, the computer would execute different commands such as stop tape, start tape, fast forward tape, etc.

    Fast forwarding was another stroke of genius because this allowed code branching. This seems obvious and easy to do today with a gazillion gigabytes of RAM into which to load your code. But, back in 1977 the CyberVision had just 2K of RAM to work with. That meant, for example, if your code was 16K in size and you had just 2K to store it, you had to do something with the other 14K of code. Well, it was stored on the tape and loaded as needed. Brilliant!

    (I am intrigued by Ken's remark about it also being able to control fast forward, which may be in error. My current understanding is that fast forwarding remains a semi-manual process, as explained below.)

    General Lifecycle of Cassette Loading and Interactivity

    The below sequence is my current understanding and confirmed functionality after a lot of experimentation, since documentation and cassette tapes are very scarce-to-non-existent.

    1. User inserts the cassette tape (Cybersette). Let's assume they also rewind it to the beginning.
    2. User powers on the Cybervision 2001 via power switch in back.
    3. User presses PLAY on the cassette player to begin reading the tape.
    4. The initial data loads a SELECTION MENU to choose from the available applications (usually 4-6 per 3o minute tape side).
    5. After the menu has loaded into memory, the data sends the aforementioned A5 series to DEACTIVATE THE CASSETTE POWER, which kills all playback instantly.
    6. A message appears advising the user to PRESS FAST FORWARD on the cassette player. This stops playback and prepares for FAST FORWARD operation, which won't do anything at this stage since the power to the cassette deck is disabled via the PCB/programming logic above.
    7. The user then presses the ON button on a controller, as advised.
    8. The menu selection appears on screen and awaits user input (by pressing the NUMBER corresponding to the program to load).
    9. On selection, the program REACTIVATES THE CASSETTE POWER to the cassette player for a particular amount of pre-programmed time. Since the user placed the cassette into FAST FORWARD mode, it will quickly begin spinning through the tape data.
    10. When the duration has elapsed, the system DEACTIVATES THE CASSETTE POWER once again. It has moved the cassette to an approximate location on the tape where the selected program data will begin.
    11. The user is instructed to press the PLAY button on the cassette and then press ON on their keypad, which once again begins playback and data loading.
    12. The chosen application itself now loads via the continued RIGHT channel data stream. Audio narration usually kicks on during this sequence as well, through the LEFT channel input.
    13. At various points throughout the program, the cassette interface power will be cut and restored to accommodate user input.

    As I go through the cassette I've been testing (Introductory Series 1) I discover other things as I try to map particular datapoints and correlations to on-screen activity. You can actually begin loading any of the applications by beginning playback at their respective points. I found that a textual notice appears on screen 30 seconds and 15 seconds before the application data itself begins to load. This is a pretty clever and convenient way to give a heads up to the user how far away they are from the next application.

    Also, if you attempt playback in the middle of data or in a way that clashes with the intended program behavior, a message will appear advising you to c.eck the tape. You then generally need to do a hard reset and begin again.

    Cassette Data Feed, Sensitivity, Timing and Adjustments

    At some point along my repairs I noticed that it grew a lot more difficult to pull in functional data reads no matter the volume, input source or base audio.

    The right audio input signal feeds through a Bourns 3355 variable resistor (10k?), .01 cap among a few other connected components. It arrives into U26 (CD4098BE - CMOS Dual Monostable Multivibrator) via pin 14-15 (RxCx2 and Cx2).  This all relates to timing and eventually reaches the channel 2 clock input, pin 11, of U25 (CD4013BE). And then finally this feeds into the A/B input of U24 (CD4034BE) which is what communicates with U22 (ROM) to parse the data.

    I concluded the variable resistor had been rotated as part of some other prior work, and is extremely sensitive to the incoming data frequency. So even though it could be off quite a bit and still detect the opening cassette data transmission, it would fail after that.

    Eventually I arrived at the sweet spot of 5.493K reading on the resistor. Which seems to load in data well without particular concern over original audio volume and I had success at 20%, 50%, 75% and 100% volume levels from my extracted audio tests.

    Audio Amplifier

    As I begin diagnosing the cassette deck itself, which previously went up into various puffs of smoke, the easiest point to start with is the audio amplifier itself. This is a self-contained PCB stamped 1215 AUDIO AMP. Currently the issue seems there are no volts getting to it from the maze of cassette deck PCB components. I have verified that the tape head is operational and can hear faint audio directly from those components, but it falls off by the time it reaches the terminal strip with large capacitor, which is what in turn runs into the amp PCB.

    The heart of the amplifier is the 8-pin CA3130E op-amp. Wires feed into this from the volume potentiometer ("IN"), internal speaker +/- (SPKR), and two lines from the terminal resistor mounted to the cassette deck itself (+ / -). On this chip, pins 4 + 7 correspond to V- and V+, pins 2-3 for NON-INV and INV input, and 6 for OUTPUT.

    • PIN 2 (INV. INPUT) is tied to the IN wire from potentiometer.
    • PIN 4 (V-) is tied to the SPKR - as well as the negative (-) input wire.
    • PIN 6 (OUTPUT) runs to the base of both transistors.
    • PIN 7 (V+) is tied to the positive (+) input wire and loops to PIN 3 (NON INV. INPUT)

    Controller Problems and Analysis

    After wrestling with the cassette interfacing and creating my own hardwired aux in for testing, I discovered various controller malfunctions. Both the LEFT and RIGHT controllers are said to be usable interchangeably and in most instances this appears to be correct. But I discovered that certain buttons on certain controllers just were not working. The keypad is arranged in a 5x8 matrix.

    Controller Pin-Out

    Each controller has a 13 wire ribbon connector running into a large 24-pin male connector, that plugs into matched female sockets on the enclosure. The connectors are branded Burndy, which to this day remains a large connector manufacturer. A little scrounging around on connector part websites, and I found the actual part numbers for both the plug and the socket!

    • 70 7156-00 - Connector, 24 Pin Plug - Burndy SMS24P-1 (51-406580)
    • 70 7157-00 - Connector, 24 Pin Socket - Burndy SMS24R-1 (51-406581)

    These can still at least be somewhat found on sites like Mouser and eBay, and here's a site that also contains a catalog/datasheet and more details. Knowing what sockets it used is helpful, and they also seem to be reasonable candidates for 3D printing as well. Read Full Article